rasti-db 1.4.0 → 2.2.0

data/spec/computed_attribute_spec.rb

@@ -0,0 +1,32 @@
+require 'minitest_helper'
+
+describe 'ComputedAttribute' do
+
+  it 'Apply Join wiht join attribute must generate correct query' do
+    dataset = db[:users]
+    computed_attribute = Rasti::DB::ComputedAttribute.new(Sequel[:comments_count][:value]) do |dataset|
+      subquery = dataset.db.from(:comments)
+                           .select(Sequel[:user_id], Sequel.function('count', :id).as(:value))
+                           .group(:user_id)
+                           .as(:comments_count)
+
+      dataset.join_table(:inner, subquery, :user_id => :id)
+    end
+    expected_query = "SELECT *, `comments_count`.`value` AS 'value' FROM `users` INNER JOIN (SELECT `user_id`, count(`id`) AS 'value' FROM `comments` GROUP BY `user_id`) AS 'comments_count' ON (`comments_count`.`user_id` = `users`.`id`)"
+    computed_attribute.apply_join(dataset)
+                      .select_append(computed_attribute.identifier)
+                      .sql
+                      .must_equal expected_query
+  end
+
+  it 'Apply join without join attribute must generate correct query' do
+    dataset = db[:people]
+    computed_attribute = Rasti::DB::ComputedAttribute.new Sequel.join([:first_name, ' ', :last_name])
+    expected_query = "SELECT * FROM `people` WHERE ((`first_name` || ' ' || `last_name`) = 'FULL NAME')"
+    computed_attribute.apply_join(dataset)
+                      .where(computed_attribute.identifier => 'FULL NAME')
+                      .sql
+                      .must_equal expected_query
+  end
+
+end

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'
@@ -12,21 +13,35 @@ Rasti::DB.configure do |config|
   config.type_converters = [Rasti::DB::TypeConverters::TimeInZone]
 end
 
-User     = Rasti::DB::Model[:id, :name, :posts, :comments, :person]
-Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories]
+User     = Rasti::DB::Model[:id, :name, :posts, :comments, :person, :comments_count]
+Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories, :language_id, :language, :notice, :author]
 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, :full_name]
+Language = Rasti::DB::Model[:id, :name, :people]
 
 
 class Users < Rasti::DB::Collection
   one_to_many :posts
   one_to_many :comments
   one_to_one :person
+
+  computed_attribute :comments_count do
+    Rasti::DB::ComputedAttribute.new(Sequel[:comments_count][:value]) do |dataset|
+      subquery = dataset.db.from(:comments)
+                           .select(Sequel[:user_id], Sequel.function('count', :id).as(:value))
+                           .group(:user_id)
+                           .as(:comments_count)
+
+      dataset.join_table(:inner, subquery, :user_id => :id)
+    end
+  end
+
 end
 
 class Posts < Rasti::DB::Collection
   many_to_one :user
+  many_to_one :language
   many_to_many :categories
   one_to_many :comments
 
@@ -38,12 +53,21 @@ 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
+
+  computed_attribute :notice do
+    Rasti::DB::ComputedAttribute.new Sequel.join([:title, ': ', :body])
+  end
+
+  computed_attribute :author do
+    Rasti::DB::ComputedAttribute.new Sequel[:user]
+  end
+
 end
 
 class Comments < Rasti::DB::Collection
@@ -52,8 +76,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 +93,43 @@ class People < Rasti::DB::Collection
   set_model Person
 
   many_to_one :user
+  many_to_many :languages
+
+  computed_attribute :full_name do |db|
+    Rasti::DB::ComputedAttribute.new Sequel.join([:first_name, ' ', :last_name])
+  end
+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 +141,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 +171,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
 
@@ -42,7 +42,7 @@ describe 'Model' do
   describe 'To String' do
     
     it 'Class' do
-      User.to_s.must_equal 'User[id, name, posts, comments, person]'
+      User.to_s.must_equal 'User[id, name, posts, comments, person, comments_count]'
     end
 
     it 'Instance' do
@@ -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/nql/computed_attributes_spec.rb

@@ -0,0 +1,29 @@
+require 'minitest_helper'
+
+describe 'NQL::ComputedAttributes' do
+
+  let(:parser) { Rasti::DB::NQL::SyntaxParser.new }
+
+  def parse(expression)
+    parser.parse expression
+  end
+
+  it 'must have one computed attributes' do
+    tree = parse 'notice = any notice'
+
+    tree.computed_attributes(Posts).must_equal [:notice]
+  end
+
+  it 'must have multiple computed attributes' do
+    tree = parse 'notice = any notice & (author: anonym | title = good morning)'
+
+    tree.computed_attributes(Posts).must_equal [:notice, :author]
+  end
+
+  it 'must have not repeated computed attributes when expression have it' do
+    tree = parse 'notice = Hi | notice = Bye'
+
+    tree.computed_attributes(Posts).must_equal [:notice]
+  end
+
+end

data/spec/nql/filter_condition_spec.rb

@@ -4,9 +4,11 @@ describe 'NQL::FilterCondition' do
 
   let(:parser) { Rasti::DB::NQL::SyntaxParser.new }
 
+  let(:collection_class) { Rasti::DB::Collection }
+
   def filter_condition(expression)
     tree = parser.parse expression
-    tree.filter_condition
+    tree.filter_condition(collection_class)
   end
 
   def assert_identifier(identifier, expected_value)
@@ -95,7 +97,7 @@ describe 'NQL::FilterCondition' do
 
   end
 
-  it 'must create filter from expression with field with multiple tables' do
+  it 'must create filter from expression with attribute with multiple tables' do
     filter = filter_condition 'table_one.table_two.column = test'
     identifier, value = filter.first
 

data/spec/nql/syntax_parser_spec.rb

@@ -31,7 +31,7 @@ describe 'NQL::SyntaxParser' do
           proposition = tree.proposition
           proposition.must_be_instance_of node_class
           proposition.comparator.text_value.must_equal comparator
-          proposition.field.text_value.must_equal 'column'
+          proposition.attribute.text_value.must_equal 'column'
           proposition.argument.text_value.must_equal 'value'
         end
       end
@@ -44,7 +44,7 @@ describe 'NQL::SyntaxParser' do
       proposition = tree.proposition
       proposition.must_be_instance_of Rasti::DB::NQL::Nodes::Comparisons::Equal
       proposition.comparator.text_value.must_equal '='
-      proposition.field.text_value.must_equal 'column'
+      proposition.attribute.text_value.must_equal 'column'
       proposition.argument.text_value.must_equal 'value'
     end
 
@@ -128,12 +128,19 @@ describe 'NQL::SyntaxParser' do
     
     end
 
-    it 'must parse expression with field with tables' do
+    it 'must parse expression with attribute with tables' do
       tree = parse 'relation_table_one.relation_table_two.column = 1'
 
-      left_hand_operand = tree.proposition.field
+      left_hand_operand = tree.proposition.attribute
       left_hand_operand.tables.must_equal ['relation_table_one', 'relation_table_two']
-      left_hand_operand.column.must_equal 'column'
+      left_hand_operand.column.must_equal :column
+    end
+
+    it 'must parse expression with computed attribute' do
+      tree = parse 'comments_count = 1'
+      computed = tree.proposition.attribute
+      computed.tables.must_equal []
+      computed.computed_attributes(Users).must_equal [:comments_count]
     end
 
   end

data/spec/query_spec.rb

@@ -3,18 +3,46 @@ 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: '...'
+    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
+
+    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}" }
+
+    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 Users, db[:users] }
+  let(:users_query) { Rasti::DB::Query.new collection_class: Users, dataset: db[:users], environment: environment }
 
-  let(:posts_query) { Rasti::DB::Query.new Posts, db[:posts] }
-  
-  let(:comments_query) { Rasti::DB::Query.new Comments, db[:comments] }
+  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], environment: environment }
+
+  let(:people_query) { Rasti::DB::Query.new collection_class: People, dataset: db[:people], 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 +65,107 @@ 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
+
+  describe 'Select computed attributes' do
+    it 'With join' do
+      db[:comments].insert post_id: 1, user_id: 5, text: 'Comment 4'
+      users_query.select_computed_attributes(:comments_count)
+                 .where(id: 5)
+                 .all
+                 .must_equal [User.new(id: 5, name: 'User 5', comments_count: 2)]
+    end
+
+    it 'Without join' do
+      person_expected = Person.new user_id: 1,
+                                   document_number: 'document_1',
+                                   first_name: 'Name 1',
+                                   last_name: 'Last Name 1',
+                                   birth_date: Date.parse('2020-04-24'),
+                                   full_name: 'Name 1 Last Name 1'
+
+      people_query.select_computed_attributes(:full_name)
+                  .where(document_number: 'document_1')
+                  .all
+                  .must_equal [person_expected]
+    end
+  end
+
   it 'Map' do
     users_query.map(&:name).must_equal db[:users].map(:name)
   end
@@ -45,45 +174,88 @@ describe 'Query' do
     users_query.detect(id: 3).must_equal User.new(id: 3, name: 'User 3')
   end
 
+  describe 'Each' do
+
+    it 'without size' do
+      users = []
+
+      users_query.each do |user|
+        users << user
+      end
+
+      users.size.must_equal 10
+      users.each_with_index do |user, i|
+        user.must_equal User.new(id: i+1, name: "User #{i+1}")
+      end
+    end
+
+    it 'with size' do
+      users = []
+      users_query.each(batch_size: 2) do |user|
+        users << user
+      end
+
+      users.size.must_equal 10
+      users.each_with_index do |user, i|
+        user.must_equal User.new(id: i+1, name: "User #{i+1}")
+      end
+    end
+
+  end
+
+  it 'Each batch' do
+    users_batch = []
+    users_query.each_batch(size: 2) do |page|
+      users_batch << page
+    end
+
+    users_batch.size.must_equal 5
+    i = 1
+    users_batch.each do |user_page|
+      user_page.must_equal [User.new(id: i, name: "User #{i}"), User.new(id: i+1, name: "User #{i+1}")]
+      i += 2
+    end
+  end
+
   it 'Where' do
     users_query.where(id: 3).all.must_equal [User.new(id: 3, name: 'User 3')]
   end
-  
+
   it 'Exclude' do
     users_query.exclude(id: [1,2,3,4,5,6,7,8,9]).all.must_equal [User.new(id: 10, name: 'User 10')]
   end
-  
+
   it 'And' do
     users_query.where(id: [1,2]).where(name: 'User 2').all.must_equal [User.new(id: 2, name: 'User 2')]
   end
-  
+
   it 'Or' do
     users_query.where(id: 1).or(name: 'User 2').all.must_equal [
-      User.new(id: 1, name: 'User 1'), 
+      User.new(id: 1, name: 'User 1'),
       User.new(id: 2, name: 'User 2')
     ]
   end
-  
+
   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
-  
+
   it 'Limit and offset' do
     users_query.limit(1).offset(1).all.must_equal [User.new(id: 2, name: 'User 2')]
   end
-  
+
   it 'First' do
     users_query.first.must_equal User.new(id: 1, name: 'User 1')
   end
@@ -93,21 +265,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 +325,143 @@ 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
 
-      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'
+      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
 
-      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]
+    it 'Filter to self table' do
+      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
+
+    describe 'Computed Attributes' do
+
+      it 'Filter relation computed attribute' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'Comment 4'
+        users_query.nql('comments_count = 2').all.must_equal [User.new(id: 5, name: 'User 5')]
+      end
+
+      it 'Filter with relation computed attribute with "and" combined' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'Comment 4'
+        db[:comments].insert post_id: 1, user_id: 4, text: 'Comment 3'
+        users_query.nql('(comments_count > 1) & (id = 5)').all.must_equal [User.new(id: 5, name: 'User 5')]
+      end
+
+      it 'Filter relation computed attribute with "or" combined' do
+        db[:comments].insert post_id: 1, user_id: 2, text: 'Comment 3'
+        users_query.nql('(comments_count = 2) | (id = 5)')
+                  .order(:id)
+                  .all
+                  .must_equal [ User.new(id: 2, name: 'User 2'), User.new(id: 5, name: 'User 5') ]
+      end
+
+      it 'Filter relation computed attribute with "and" and "or" combined' do
+        db[:comments].insert post_id: 1, user_id: 2, text: 'Comment 3'
+        users_query.nql('((comments_count = 2) | (id = 5)) & (name: User 5)')
+                  .order(:id)
+                  .all
+                  .must_equal [ User.new(id: 5, name: 'User 5') ]
+      end
+
+      it 'Filter simple computed attribute' do
+        person_expected = Person.new user_id: 1,
+                                     document_number: 'document_1',
+                                     first_name: 'Name 1',
+                                     last_name: 'Last Name 1',
+                                     birth_date: Date.parse('2020-04-24')
+
+        people_query.nql('full_name = Name 1 Last Name 1')
+                    .all
+                    .must_equal [person_expected]
+      end
+
+    end
+
   end
 
 end