rasti-db 4.1.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c26c0f818529ec0d1a752cf310c1d23cf235d2c8c83e13a62d8d61bc90b3b400
-  data.tar.gz: 57022ffbb145a76ad9532d16a1ed890f31862f7fc6ad4cea6d40aae0490908ca
+  metadata.gz: fa10d65e8a9fbd3c311384e8806addd5c04b803405444717d6904282dbf9207c
+  data.tar.gz: 24f1e8801906634288e62ef7337da1179392e75203b08ae6f034b5f25256228e
 SHA512:
-  metadata.gz: 94746821604273fdf6483d5410f8c73f4793901116478a17d3ecba6e7039705ecf8cf5b8ad0ccb30adb294d052ff144c6d0fe5ca042ca1fd558e3caf5c45de62
-  data.tar.gz: '0684ae374582f8cd633d44aacd720e80b3575e3ef8186de2252d9f73e17f03fe438a54a407127bb320f9ec8996f3f5dc71c99294b503c28797e34faf4c886f22'
+  metadata.gz: 04a6c1deb6afa47fae66203bec39d81926ac5e6435844593c321279423d6a8a5651178fc5769e58868f88286ae819ecfd7aa77785b2e6df82cd63096d12ee34f
+  data.tar.gz: 28ec23866d539f20163bff9449586060d1f943d022f10f72d2d4b4ff5f3fc8b9db97acbefa2482fcc262d0e51625bad603ea3861fbea7f47fe36382ce9da5821

data/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  push:
+    branches: [ '**' ]
+  pull_request:
+    branches: [ '**' ]
+
+jobs:
+  test:
+
+    name: Tests
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.3', '2.4', '2.5', '2.6', '2.7', '3.0', 'jruby-9.2.9.0']
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - name: Run tests
+      run: bundle exec rake

data/README.md

@@ -1,7 +1,7 @@
 # Rasti::DB
 
 [![Gem Version](https://badge.fury.io/rb/rasti-db.svg)](https://rubygems.org/gems/rasti-db)
-[![Build Status](https://travis-ci.org/gabynaiman/rasti-db.svg?branch=master)](https://travis-ci.org/gabynaiman/rasti-db)
+[![CI](https://github.com/gabynaiman/rasti-db/actions/workflows/ci.yml/badge.svg)](https://github.com/gabynaiman/rasti-db/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/github/gabynaiman/rasti-db/badge.svg?branch=master)](https://coveralls.io/github/gabynaiman/rasti-db?branch=master)
 [![Code Climate](https://codeclimate.com/github/gabynaiman/rasti-db.svg)](https://codeclimate.com/github/gabynaiman/rasti-db)
 

data/lib/rasti/db/query.rb

@@ -53,22 +53,24 @@ module Rasti
         build_query relations_graph: relations_graph.merge(excluded_attributes: excluded_attributes)
       end
 
+      def graph_queries(queries)
+        build_query relations_graph: relations_graph.merge(queries: queries)
+      end
+
       def all_graph_attributes(*relations)
         build_query relations_graph: relations_graph.with_all_attributes_for(relations)
       end
 
       def select_computed_attributes(*computed_attributes)
-        ds = computed_attributes.inject(dataset) do |ds, name|
+        ds = computed_attributes.inject(dataset) do |inner_ds, name|
           computed_attribute = collection_class.computed_attributes[name]
-          computed_attribute.apply_join(ds, environment).select_append(computed_attribute.identifier.as(name))
+          computed_attribute.apply_join(inner_ds, environment).select_append(computed_attribute.identifier.as(name))
         end
         build_query dataset: ds
       end
 
       def all
-        with_graph(dataset.all).map do |row|
-          collection_class.model.new row
-        end
+        build_models dataset.all
       end
       alias_method :to_a, :all
 
@@ -114,13 +116,11 @@ module Rasti
       end
 
       def first
-        row = dataset.first
-        row ? build_model(row) : nil
+        build_model dataset.first
       end
 
       def last
-        row = dataset.last
-        row ? build_model(row) : nil
+        build_model dataset.last
       end
 
       def detect(*args, &block)
@@ -137,8 +137,8 @@ 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, environment
+        ds = sentence.computed_attributes(collection_class).inject(dataset) do |inner_ds, name|
+          collection_class.computed_attributes[name].apply_join inner_ds, environment
         end
         query = build_query dataset: ds
 
@@ -164,7 +164,21 @@ module Rasti
       end
 
       def build_model(row)
-        collection_class.model.new with_graph(row)
+        row ? build_models([row]).first : nil
+      end
+
+      def build_models(rows)
+        with_graph(rows).map do |row|
+          collection_class.model.new slice_defined_attributes(row)
+        end
+      end
+
+      def slice_defined_attributes(row)
+        row.select { |k,_| defined_attributes.include? k }
+      end
+
+      def defined_attributes
+        @defined_attributes ||= collection_class.model.attribute_names.to_set
       end
 
       def chainable(&block)
@@ -205,4 +219,4 @@ module Rasti
 
     end
   end
-end
+end

data/lib/rasti/db/relations/graph.rb

@@ -3,20 +3,22 @@ module Rasti
     module Relations
       class Graph
 
-        def initialize(environment, collection_class, relations=[], selected_attributes={}, excluded_attributes={})
+        def initialize(environment, collection_class, relations=[], selected_attributes={}, excluded_attributes={}, queries={})
           @environment = environment
           @collection_class = collection_class
           @graph = build_graph relations,
                                Hash::Indifferent.new(selected_attributes),
-                               Hash::Indifferent.new(excluded_attributes)
+                               Hash::Indifferent.new(excluded_attributes),
+                               Hash::Indifferent.new(queries)
         end
 
-        def merge(relations:[], selected_attributes:{}, excluded_attributes:{})
+        def merge(relations:[], selected_attributes:{}, excluded_attributes:{}, queries: {})
           Graph.new environment,
                     collection_class,
                     (flat_relations | relations),
                     flat_selected_attributes.merge(selected_attributes),
-                    flat_excluded_attributes.merge(excluded_attributes)
+                    flat_excluded_attributes.merge(excluded_attributes),
+                    flat_queries.merge(queries)
         end
 
         def with_all_attributes_for(relations)
@@ -30,16 +32,17 @@ module Rasti
           query.graph(*flat_relations)
                .select_graph_attributes(flat_selected_attributes)
                .exclude_graph_attributes(flat_excluded_attributes)
+               .graph_queries(flat_queries)
         end
 
         def fetch_graph(rows)
           return if rows.empty?
-
           graph.roots.each do |node|
             relation_of(node).fetch_graph environment,
                                           rows,
                                           node[:selected_attributes],
-                                          node[:excluded_attributes] ,
+                                          node[:excluded_attributes],
+                                          node[:queries] ,
                                           subgraph_of(node)
           end
         end
@@ -76,33 +79,43 @@ module Rasti
           end
         end
 
+        def flat_queries
+          graph.each_with_object(Hash::Indifferent.new) do |node, hash|
+            hash[node.id] = node[:queries]
+          end
+        end
+
         def subgraph_of(node)
           relations = []
           selected = Hash::Indifferent.new
           excluded = Hash::Indifferent.new
+          queries = Hash::Indifferent.new
 
           node.descendants.each do |descendant|
             id = descendant.id[node[:name].length+1..-1]
             relations << id
             selected[id] = descendant[:selected_attributes]
             excluded[id] = descendant[:excluded_attributes]
+            queries[id] = descendant[:queries]
           end
 
           Graph.new environment,
                     relation_of(node).target_collection_class,
                     relations,
                     selected,
-                    excluded
+                    excluded,
+                    queries
         end
 
-        def build_graph(relations, selected_attributes, excluded_attributes)
+        def build_graph(relations, selected_attributes, excluded_attributes, queries)
           HierarchicalGraph.new.tap do |graph|
             flatten(relations).each do |relation|
               sections = relation.split('.')
 
               graph.add_node relation, name: sections.last.to_sym,
                                        selected_attributes: selected_attributes[relation],
-                                       excluded_attributes: excluded_attributes[relation]
+                                       excluded_attributes: excluded_attributes[relation],
+                                       queries: queries[relation]
 
               if sections.count > 1
                 parent_id = sections[0..-2].join('.')
@@ -126,4 +139,4 @@ module Rasti
       end
     end
   end
-end
+end

data/lib/rasti/db/relations/many_to_many.rb

@@ -19,9 +19,9 @@ module Rasti
           @relation_data_source_name ||= options[:relation_data_source_name] || source_collection_class.data_source_name
         end
 
-        def fetch_graph(environment, rows, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
+        def fetch_graph(environment, rows, selected_attributes=nil, excluded_attributes=nil, queries=nil, relations_graph=nil)
           pks = rows.map { |row| row[source_collection_class.primary_key] }
-
+          
           if target_collection_class.data_source_name == relation_data_source_name
             target_data_source = environment.data_source_of target_collection_class
 
@@ -30,10 +30,14 @@ module Rasti
                                            .where(Sequel[relation_collection_name][source_foreign_key] => pks)
                                            .select_all(target_collection_class.collection_name)
 
-            selected_attributes ||= target_collection_class.collection_attributes - excluded_attributes if excluded_attributes
-            dataset = dataset.select(*selected_attributes.map { |a| Sequel[target_collection_class.collection_name][a] }) if selected_attributes
+            selected_attributes ||= target_collection_class.collection_attributes - excluded_attributes unless excluded_attributes.nil?
+            dataset = dataset.select(*selected_attributes.map { |a| Sequel[target_collection_class.collection_name][a] }) unless selected_attributes.nil?
+
+            query = Query.new collection_class: target_collection_class, dataset: dataset, environment: environment
+            query = queries.inject(query) { |new_query, sub_query| new_query.send(sub_query) } unless queries.nil?
+
+            join_rows = query.send(:dataset).select_append(Sequel[relation_collection_name][source_foreign_key].as(:source_foreign_key)).all
 
-            join_rows = dataset.select_append(Sequel[relation_collection_name][source_foreign_key].as(:source_foreign_key)).all
           else
             relation_data_source = environment.data_source relation_data_source_name
 
@@ -42,8 +46,10 @@ module Rasti
                                                     .select_hash_groups(target_foreign_key, source_foreign_key)
 
             query = target_collection_class.new environment
-            query = query.exclude_attributes(*excluded_attributes) if excluded_attributes
-            query = query.select_attributes(*selected_attributes) if selected_attributes
+            query = query.exclude_attributes(*excluded_attributes) unless excluded_attributes.nil?
+            query = query.select_attributes(*selected_attributes) unless selected_attributes.nil?
+
+            query = queries.inject(query) { |new_query, sub_query| new_query.send(sub_query) } unless queries.nil?
 
             join_rows = query.where(target_collection_class.primary_key => relation_index.keys).raw.flat_map do |row|
               relation_index[row[target_collection_class.primary_key]].map do |source_primary_key|
@@ -110,4 +116,4 @@ module Rasti
       end
     end
   end
-end
+end

data/lib/rasti/db/relations/many_to_one.rb

@@ -7,14 +7,18 @@ module Rasti
           @foreign_key ||= options[:foreign_key] || target_collection_class.foreign_key
         end
 
-        def fetch_graph(environment, rows, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
+        def fetch_graph(environment, rows, selected_attributes=nil, excluded_attributes=nil, queries=nil, relations_graph=nil)
           fks = rows.map { |row| row[foreign_key] }.uniq
 
           target_collection = target_collection_class.new environment
 
           query = target_collection.where(source_collection_class.primary_key => fks)
-          query = query.exclude_attributes(*excluded_attributes) if excluded_attributes
-          query = query.select_attributes(*selected_attributes) if selected_attributes
+
+          query = query.exclude_attributes(*excluded_attributes) unless excluded_attributes.nil?
+          query = query.select_attributes(*selected_attributes) unless selected_attributes.nil?
+
+          query = queries.inject(query) { |new_query, sub_query| new_query.send(sub_query) } unless queries.nil?
+
           query = relations_graph.apply_to query if relations_graph
 
           relation_rows = query.each_with_object({}) do |row, hash|
@@ -47,4 +51,4 @@ module Rasti
       end
     end
   end
-end
+end

data/lib/rasti/db/relations/one_to_many.rb

@@ -7,14 +7,17 @@ module Rasti
           @foreign_key ||= options[:foreign_key] || source_collection_class.foreign_key
         end
 
-        def fetch_graph(environment, rows, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
+        def fetch_graph(environment, rows, selected_attributes=nil, excluded_attributes=nil, queries=nil, relations_graph=nil)
           pks = rows.map { |row| row[source_collection_class.primary_key] }.uniq
 
           target_collection = target_collection_class.new environment
 
           query = target_collection.where(foreign_key => pks)
-          query = query.exclude_attributes(*excluded_attributes) if excluded_attributes
-          query = query.select_attributes(*selected_attributes) if selected_attributes
+          query = query.exclude_attributes(*excluded_attributes) unless excluded_attributes.nil?
+          query = query.select_attributes(*selected_attributes) unless selected_attributes.nil?
+
+          query = queries.inject(query) { |new_query, sub_query| new_query.send(sub_query) } unless queries.nil?
+
           query = relations_graph.apply_to query if relations_graph
 
           relation_rows = query.group_by(&foreign_key)
@@ -62,4 +65,4 @@ module Rasti
       end
     end
   end
-end
+end

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '4.1.0'
+    VERSION = '4.2.0'
   end
 end

data/spec/minitest_helper.rb

@@ -19,10 +19,12 @@ Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :cat
 Comment  = Rasti::DB::Model[:id, :text, :user_id, :user, :post_id, :post, :tags]
 Category = Rasti::DB::Model[:id, :name, :posts]
 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]
+Language = Rasti::DB::Model[:id, :name, :people, :countries]
+Country  = Rasti::DB::Model[:id, :name, :population, :language_id]
 
 
 class Users < Rasti::DB::Collection
+
   one_to_many :posts
   one_to_many :comments
   one_to_one :person
@@ -41,14 +43,15 @@ class Users < Rasti::DB::Collection
 end
 
 class Posts < Rasti::DB::Collection
+
   many_to_one :user
   many_to_one :language
   many_to_many :categories
   one_to_many :comments
 
   query :created_by, ->(user_id) { where user_id: user_id }
-  
-  query :entitled do |title| 
+
+  query :entitled do |title|
     where title: title
   end
 
@@ -61,6 +64,18 @@ class Posts < Rasti::DB::Collection
     end
   end
 
+  query :only_title do
+    chainable do
+      dataset.select(:title).select_append(:id, :user_id)
+    end
+  end
+
+  query :append_body do
+    chainable do
+      dataset.select_append(:body)
+    end
+  end
+
   computed_attribute :notice do
     Rasti::DB::ComputedAttribute.new Sequel.join([:title, ': ', :body])
   end
@@ -72,6 +87,7 @@ class Posts < Rasti::DB::Collection
 end
 
 class Comments < Rasti::DB::Collection
+
   many_to_one :user
   many_to_one :post
 
@@ -81,13 +97,17 @@ class Comments < Rasti::DB::Collection
            .select_all(:posts)
            .map { |row| Post.new row }
   end
+
 end
 
 class Categories < Rasti::DB::Collection
+
   many_to_many :posts
+
 end
 
 class People < Rasti::DB::Collection
+
   set_collection_name :people
   set_primary_key :document_number
   set_foreign_key :document_number
@@ -99,13 +119,23 @@ class People < Rasti::DB::Collection
   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
+  one_to_many :countries
+
+end
+
+class Countries < Rasti::DB::Collection
+
+  many_to_one :language
+
 end
 
 
@@ -114,7 +144,7 @@ class Minitest::Spec
   let(:users) { Users.new environment }
 
   let(:posts) { Posts.new environment }
-  
+
   let(:comments) { Comments.new environment }
 
   let(:categories) { Categories.new environment }
@@ -123,16 +153,17 @@ class Minitest::Spec
 
   let(:languages) { Languages.new environment }
 
+  let(:countries) { Countries.new environment }
+
   let(:driver) { (RUBY_ENGINE == 'jruby') ? 'jdbc:sqlite::memory:' : {adapter: :sqlite} }
 
-  let :environment do 
+  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
         primary_key :id
         String :name, null: false, unique: true
@@ -179,18 +210,22 @@ class Minitest::Spec
         primary_key [:language_id, :document_number]
       end
 
+      db.create_table :countries do
+        primary_key :id
+        String :name, null: false, unique: true
+        Integer :population, null: false
+        Integer :language_id, null: false, index: true
+      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
 
-end
+end

data/spec/query_spec.rb

@@ -32,6 +32,8 @@ describe 'Query' do
     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
+
+    db[:countries].insert name: 'Argentina', population: 40000000, language_id: 1
   end
 
   let(:users_query) { Rasti::DB::Query.new collection_class: Users, dataset: db[:users], environment: environment }
@@ -44,6 +46,10 @@ describe 'Query' do
 
   let(:languages_query) { Rasti::DB::Query.new collection_class: Languages, dataset: custom_db[:languages], environment: environment }
 
+  let(:countries_query) { Rasti::DB::Query.new collection_class: Countries, dataset: db[:countries], environment: environment }
+
+  let(:categories_query) { Rasti::DB::Query.new collection_class: Categories, dataset: db[:categories], environment: environment }
+
   it 'Count' do
     users_query.count.must_equal 10
   end
@@ -142,6 +148,59 @@ describe 'Query' do
                .must_equal [post]
   end
 
+  it 'Graph with query many to one' do
+    comments_query.graph('post')
+                  .graph_queries('post' => [:only_title])
+                  .where(id: 1)
+                  .all
+                  .must_equal [
+                    Comment.new(id: 1, text: 'Comment 1', user_id: 5, post_id: 1, post: Post.new(id: 1, user_id: 2, title: 'Sample post'), tags: [])
+                  ]
+  end
+
+  it 'Graph with query one to many' do
+    users_query.graph('posts')
+              .graph_queries('posts' => [:only_title])
+              .where(id: 1)
+              .all
+              .must_equal [
+                User.new(id: 1, name: 'User 1', posts: [Post.new(user_id: 1, id: 2, title: 'Another post')])
+              ]
+  end
+
+  it 'Graph with query many to many' do
+    categories_query.graph('posts')
+                    .graph_queries('posts' => [:only_title])
+                    .where(id: 1)
+                    .all
+                    .must_equal [
+                      Category.new(id: 1, name: 'Category 1', posts: [Post.new(user_id: 2, id: 1, title: 'Sample post')])
+                    ]
+  end
+
+  it 'Graph with n queries' do
+    comments_query.graph('post')
+                  .graph_queries('post' => [:only_title, :append_body])
+                  .where(id: 1)
+                  .all
+                  .must_equal [
+                    Comment.new(id: 1, text: 'Comment 1', user_id: 5, post_id: 1, post: Post.new(id: 1, user_id: 2, title: 'Sample post', body: '...'), tags: [])
+                  ]
+
+  end
+
+  it 'Graph query missing must raise error' do
+    proc { posts_query.graph('comments.user')
+                      .graph_queries('comments.user' => [:with_not_exists_query])
+                      .all }.must_raise NoMethodError
+  end
+
+  it 'Graph with query params must raise error' do
+    proc { users_query.graph('posts')
+                      .graph_queries('posts' => [:created_by])
+                      .all }.must_raise ArgumentError
+  end
+
   describe 'Select computed attributes' do
     it 'With join' do
       db[:comments].insert post_id: 1, user_id: 5, text: 'Comment 4'
@@ -166,6 +225,25 @@ describe 'Query' do
     end
   end
 
+  describe 'Ignore undefined attributes' do
+
+    it 'First level' do
+      countries_query.raw.first.must_equal id: 1,
+                                     name: 'Argentina',
+                                     population: 40000000,
+                                     language_id: 1
+
+      [countries_query.detect(id: 1), countries_query.where(id: 1).order(:name).last, countries_query.all.first].each do |country|
+        country.must_equal Country.new(language_id: 1, id: 1, name: 'Argentina', population: 40000000)
+      end
+    end
+
+    it 'Graph nested' do
+      languages_query.graph(:countries).first.countries.must_equal [Country.new(language_id: 1, id: 1, name: 'Argentina', population: 40000000)]
+    end
+
+  end
+
   it 'Map' do
     users_query.map(&:name).must_equal db[:users].map(:name)
   end
@@ -553,4 +631,4 @@ describe 'Query' do
 
   end
 
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasti-db
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.2.0
 platform: ruby
 authors:
 - Gabriel Naiman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-17 00:00:00.000000000 Z
+date: 2024-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -294,10 +294,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".coveralls.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".ruby-gemset"
 - ".ruby-version"
-- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md

data/.travis.yml

@@ -1,23 +0,0 @@
-language: ruby
-
-rvm:
-  - 2.1
-  - 2.2
-  - 2.3
-  - 2.4
-  - 2.5
-  - 2.6
-  - 2.7
-  - 3.0
-  - jruby-9.2.9.0
-  - ruby-head
-  - jruby-head
-
-matrix:
-  fast_finish: true
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
-
-jdk:
-  - openjdk8