rasti-db 2.0.1 → 2.1.0

data/lib/rasti/db/nql/syntax.treetop

@@ -42,44 +42,44 @@ module Rasti
           comparison_equal
         end
 
-        rule field
-          _tables:(table:field_name '.')* _column:field_name <Nodes::Field>
+        rule attribute
+          _tables:(table:attribute_name '.')* _column:attribute_name <Nodes::Attribute>
         end
 
         rule comparison_include
-          field:field space* comparator:':' space* argument:basic <Nodes::Comparisons::Include>
+          attribute:attribute space* comparator:':' space* argument:basic <Nodes::Comparisons::Include>
         end
 
         rule comparison_not_include
-          field:field space* comparator:'!:' space* argument:basic <Nodes::Comparisons::NotInclude>
+          attribute:attribute space* comparator:'!:' space* argument:basic <Nodes::Comparisons::NotInclude>
         end
 
         rule comparison_like
-          field:field space* comparator:'~' space* argument:basic <Nodes::Comparisons::Like>
+          attribute:attribute space* comparator:'~' space* argument:basic <Nodes::Comparisons::Like>
         end
 
         rule comparison_greater_than
-          field:field space* comparator:'>' space* argument:basic <Nodes::Comparisons::GreaterThan>
+          attribute:attribute space* comparator:'>' space* argument:basic <Nodes::Comparisons::GreaterThan>
         end
 
         rule comparison_greater_than_or_equal
-          field:field space* comparator:'>=' space* argument:basic <Nodes::Comparisons::GreaterThanOrEqual>
+          attribute:attribute space* comparator:'>=' space* argument:basic <Nodes::Comparisons::GreaterThanOrEqual>
         end
 
         rule comparison_less_than
-          field:field space* comparator:'<' space* argument:basic <Nodes::Comparisons::LessThan>
+          attribute:attribute space* comparator:'<' space* argument:basic <Nodes::Comparisons::LessThan>
         end
 
         rule comparison_less_than_or_equal
-          field:field space* comparator:'<=' space* argument:basic <Nodes::Comparisons::LessThanOrEqual>
+          attribute:attribute space* comparator:'<=' space* argument:basic <Nodes::Comparisons::LessThanOrEqual>
         end
 
         rule comparison_not_equal
-          field:field space* comparator:'!=' space* argument:basic <Nodes::Comparisons::NotEqual>
+          attribute:attribute space* comparator:'!=' space* argument:basic <Nodes::Comparisons::NotEqual>
         end
 
         rule comparison_equal
-          field:field space* comparator:'=' space* argument:basic <Nodes::Comparisons::Equal>
+          attribute:attribute space* comparator:'=' space* argument:basic <Nodes::Comparisons::Equal>
         end
 
         rule basic
@@ -95,7 +95,7 @@ module Rasti
           [\s\t\n]
         end
 
-        rule field_name
+        rule attribute_name
           [a-z_]+
         end
 

data/lib/rasti/db/query.rb

@@ -57,6 +57,12 @@ module Rasti
         build_query relations_graph: relations_graph.with_all_attributes_for(relations)
       end
 
+      def append_computed_attribute(name)
+        computed_attribute = collection_class.computed_attributes[name]
+        ds = computed_attribute.apply_join(dataset).select_append(computed_attribute.identifier.as(name))
+        build_query dataset: ds
+      end
+
       def all
         with_graph(dataset.all).map do |row| 
           collection_class.model.new row
@@ -64,8 +70,19 @@ module Rasti
       end
       alias_method :to_a, :all
 
-      def each(&block)
-        all.each(&block)
+      def each(batch_size:nil, &block)
+        if batch_size.nil?
+          all.each(&block)
+        else
+          each_model_in_batches(size: batch_size, &block)
+        end
+      end
+
+      def each_batch(size:, &block)
+        dataset.each_page(size) do |page|
+          query = build_query dataset: page
+          block.call query.all
+        end
       end
 
       def graph(*relations)
@@ -94,12 +111,12 @@ module Rasti
 
       def first
         row = dataset.first
-        row ? collection_class.model.new(with_graph(row)) : nil
+        row ? build_model(row) : nil
       end
 
       def last
         row = dataset.last
-        row ? collection_class.model.new(with_graph(row)) : nil
+        row ? build_model(row) : nil
       end
 
       def detect(*args, &block)
@@ -116,10 +133,15 @@ module Rasti
 
         raise NQL::InvalidExpressionError.new(filter_expression) if sentence.nil?
 
+        ds = sentence.computed_attributes(collection_class).inject(dataset) do |ds, name|
+          collection_class.computed_attributes[name].apply_join ds
+        end
+        query = build_query dataset: ds
+
         dependency_tables = sentence.dependency_tables
-        query = dependency_tables.empty? ? self : join(*dependency_tables)
-        
-        query.where sentence.filter_condition
+        query = query.join(*dependency_tables) unless dependency_tables.empty?
+
+        query.where sentence.filter_condition(collection_class)
       end
 
       private
@@ -137,10 +159,22 @@ module Rasti
         Query.new(**current_args.merge(args))
       end
 
+      def build_model(row)
+        collection_class.model.new with_graph(row)
+      end
+
       def chainable(&block)
         build_query dataset: instance_eval(&block)
       end
 
+      def each_model_in_batches(size:, &block)
+        dataset.each_page(size) do |page|
+          page.each do |row|
+            block.call build_model(row)
+          end
+        end
+      end
+
       def with_related(relation_name, primary_keys)
         ds = collection_class.relations[relation_name].apply_filter environment, dataset, primary_keys
         build_query dataset: ds

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '2.0.1'
+    VERSION = '2.1.0'
   end
 end

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

@@ -13,11 +13,11 @@ 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, :language_id, :language]
+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, :languages]
+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]
 
 
@@ -25,6 +25,18 @@ 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
@@ -47,6 +59,15 @@ class Posts < Rasti::DB::Collection
              .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
@@ -73,6 +94,10 @@ class People < Rasti::DB::Collection
 
   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
@@ -107,6 +132,8 @@ class Minitest::Spec
   let :db do
     Sequel.connect(driver).tap do |db|
 
+      db.extension :pagination
+
       db.create_table :users do
         primary_key :id
         String :name, null: false, unique: true

data/spec/model_spec.rb

@@ -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

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

@@ -5,13 +5,13 @@ describe 'Query' do
   before do
     custom_db[:languages].insert name: 'Spanish'
 
-    1.upto(10) do |i| 
+    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}", 
+      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}"
@@ -22,7 +22,7 @@ describe 'Query' do
     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'
@@ -35,11 +35,13 @@ describe 'Query' do
   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 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
@@ -87,8 +89,8 @@ describe 'Query' do
     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: [:id],
+      'user.person' => [:document_number, :user_id],
       'user.person.languages' => [:id],
       categories: [:id]
     }
@@ -99,7 +101,7 @@ describe 'Query' do
                .all
                .must_equal [post]
   end
-  
+
   it 'Exclude graph attributes' do
     language = Language.new custom_db[:languages].where(id: 1).select(:id).first
 
@@ -112,8 +114,8 @@ describe 'Query' do
     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: [:name],
+      'user.person' => [:first_name, :last_name, :birth_date],
       'user.person.languages' => [:name],
       categories: [:name]
     }
@@ -124,7 +126,7 @@ describe 'Query' do
                .all
                .must_equal [post]
   end
-  
+
   it 'All graph attributes' do
     person = Person.new db[:people].where(document_number: 'document_2').first
 
@@ -140,6 +142,30 @@ describe 'Query' do
                .must_equal [post]
   end
 
+  describe 'Append computed attribute' do
+    it 'With join' do
+      db[:comments].insert post_id: 1, user_id: 5, text: 'Comment 4'
+      users_query.append_computed_attribute(: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.append_computed_attribute(: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
@@ -148,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: '...', 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),
+      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: '...', language_id: 1),
-      Post.new(id: 3, user_id: 4, title: 'Best 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
@@ -203,21 +272,21 @@ describe 'Query' 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', 
+                        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, 
+    user = User.new id: 2,
                     name: 'User 2',
                     person: person
 
-    post = Post.new id: 1, 
-                    user_id: 2, 
+    post = Post.new id: 1,
+                    user_id: 2,
                     user: user,
-                    title: 'Sample post', 
-                    body: '...', 
+                    title: 'Sample post',
+                    body: '...',
                     language_id: 1,
                     language: language
 
@@ -323,7 +392,7 @@ describe 'Query' 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
       posts_query.nql('user_id > 1')
                  .pluck(:user_id)
@@ -350,6 +419,49 @@ describe 'Query' do
                  .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