rasti-db 2.0.1 → 2.3.2

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
@@ -206,4 +213,28 @@ describe 'NQL::SyntaxParser' do
 
   end
 
+  describe 'Array' do
+
+    it 'must parse array with one element' do
+      tree = parse 'column = [ a ]'
+      tree.proposition.argument.value.must_equal ['a']
+    end
+
+    it 'must parse array with many elements' do 
+      tree = parse 'column = [ a, b, c ]'
+      tree.proposition.argument.value.must_equal ['a', 'b', 'c']
+    end
+
+    it 'must parse array respecting content types' do
+      tree = parse 'column = [ true, 12:00, 1.1, 1, "literal string", string ]'
+      tree.proposition.argument.value.must_equal [true, Timing::TimeInZone.parse('12:00').to_s, 1.1, 1, "literal string", 'string']
+    end
+
+    it 'must parse array with literal string allowing reserved characters in conflict with array' do
+      tree = parse 'column = [ ",", "[", "]", "[,", "],", "[,]", "simple literal" ]'
+      tree.proposition.argument.value.must_equal [ ',', '[', ']', '[,', '],', '[,]', 'simple literal' ]
+    end
+
+  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 '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
@@ -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,138 @@ 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
+
+    describe 'Filter Array' do
+
+      def filter_condition_must_raise(comparison_symbol, comparison_name)
+        error = proc { comments_query.nql("tags #{comparison_symbol} [fake, notice]") }.must_raise Rasti::DB::NQL::FilterConditionStrategies::UnsupportedTypeComparison
+        error.argument_type.must_equal Rasti::DB::NQL::FilterConditionStrategies::Types::SQLiteArray
+        error.comparison_name.must_equal comparison_name
+        error.message.must_equal "Unsupported comparison #{comparison_name} for Rasti::DB::NQL::FilterConditionStrategies::Types::SQLiteArray"
+      end
+
+      it 'Must raise exception from not supported methods' do
+        comparisons = {
+          greater_than: '>',
+          greater_than_or_equal: '>=',
+          less_than: '<',
+          less_than_or_equal: '<='
+        }
+
+        comparisons.each do |name, symbol|
+          filter_condition_must_raise symbol, name
+        end
+      end
+
+      it 'Included any of these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice 2', tags: '["notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice 3', tags: '["fake_notice"]'
+        expected_comments = [
+          Comment.new(id: 4, text: 'fake notice', tags: ['fake','notice'], user_id: 5, post_id: 1),
+          Comment.new(id: 5, text: 'fake notice 2', tags: ['notice'], user_id: 5, post_id: 1)
+        ]
+
+        comments_query.nql('tags: [ fake, notice ]')
+                    .all
+                    .must_equal expected_comments
+      end
+
+      it 'Included exactly all these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice 2', tags: '["notice"]'
+        comments_query.nql('tags = [fake, notice]')
+                    .all
+                    .must_equal [Comment.new(id: 4, text: 'fake notice', tags: ['fake','notice'], user_id: 5, post_id: 1)]
+      end
+
+      it 'Not included anyone of these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'Good notice!', tags: '["good"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake"]'
+        expected_comments = [
+          Comment.new(id: 1, text: 'Comment 1', tags: [], user_id: 5, post_id: 1),
+          Comment.new(id: 2, text: 'Comment 2', tags: [], user_id: 7, post_id: 1),
+          Comment.new(id: 3, text: 'Comment 3', tags: [], user_id: 2, post_id: 2),
+          Comment.new(id: 5, text: 'Good notice!', tags: ['good'], user_id: 5, post_id: 1)
+        ]
+        comments_query.nql('tags !: [fake, notice]')
+                    .all
+                    .must_equal expected_comments
+      end
+
+      it 'Not include any of these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'Good notice!', tags: '["good"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake"]'
+        expected_comments = [
+          Comment.new(id: 1, text: 'Comment 1', tags: '[]', user_id: 5, post_id: 1),
+          Comment.new(id: 2, text: 'Comment 2', tags: '[]', user_id: 7, post_id: 1),
+          Comment.new(id: 3, text: 'Comment 3', tags: '[]', user_id: 2, post_id: 2),
+          Comment.new(id: 5, text: 'Good notice!', tags: ['good'], user_id: 5, post_id: 1),
+          Comment.new(id: 6, text: 'fake notice', tags: ['fake'], user_id: 5, post_id: 1)
+        ]
+        comments_query.nql('tags != [fake, notice]')
+                    .all
+                    .must_equal expected_comments
+      end
+
+      it 'Include any like these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'this is a fake notice!', tags: '["fake_notice"]'
+        expected_comments = [
+          Comment.new(id: 4, text: 'fake notice', tags: ['fake','notice'], user_id: 5, post_id: 1),
+          Comment.new(id: 5, text: 'this is a fake notice!', tags: ['fake_notice'], user_id: 5, post_id: 1)
+        ]
+        comments_query.nql('tags ~ [fake]')
+                      .all
+                      .must_equal expected_comments
+      end
+
+    end
+
   end
 
 end