rasti-db 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed5332eda8adfde54d7465d8f3f631d9b542f54d17c78644703d2f9054cb1bca
-  data.tar.gz: 5452a867c32c4083f10149c3496093e731d6f8d64a6b13fafd57ebcc0d7e38c8
+  metadata.gz: b801c94dd51c4ee11f624cb542d784a42e445622e0090c42cb9d47322b87e855
+  data.tar.gz: 518c58daf408e477f80cdac52837a0e2d3256938352c888a73e369f3eca5b7a2
 SHA512:
-  metadata.gz: 31a039adaeb64c98fa7f5c38b2155a009f78e2a824d9c8d4e9969bd2d9ff7599afc899d5b10c3864694a22540061cf0f439f681792f2f89e9eb9da030aa7c28e
-  data.tar.gz: 393c7b91108ff8ab2c8effed2016b4ea912747baf65194c05614a01ef9d4d4447d41f350e996f0bdf8b14b9de102ced09bd023ce9cef590306068c28a8ae051c
+  metadata.gz: ae1452c9b77c6d50f9aa8b05b85f9970c801369e7e3a67a7a88436762fbacea4191390e114be066458d7bc2dc563f834cda93a364185354c74267db86798a889
+  data.tar.gz: 2707b44943ea63f17cd0f613c4fa08bdfc0663e8fde17f604c8c6ce9ba8f1fff23b4fa1641dfe42f77810a55fda6794491f5e8d8cb756c4fc19adb1cbb8cba76

data/.travis.yml

@@ -1,7 +1,6 @@
 language: ruby
 
 rvm:
-  - 2.0
   - 2.1
   - 2.2
   - 2.3
@@ -9,8 +8,7 @@ rvm:
   - 2.5
   - 2.6
   - 2.7
-  - jruby-9.1.7.0
-  - jruby-9.1.16.0
+  - jruby-9.2.9.0
   - ruby-head
   - jruby-head
 

data/README.md

@@ -4,7 +4,6 @@
 [![Build Status](https://travis-ci.org/gabynaiman/rasti-db.svg?branch=master)](https://travis-ci.org/gabynaiman/rasti-db)
 [![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)
-[![Dependency Status](https://gemnasium.com/gabynaiman/rasti-db.svg)](https://gemnasium.com/gabynaiman/rasti-db)
 
 Database collections and relations
 
@@ -108,7 +107,7 @@ class Posts < Rasti::DB::Collection
     chainable do
       dataset.join(with_schema(:comments), post_id: :id)
              .where(with_schema(:comments, :user_id) => user_id)
-             .select_all(with_schema(:posts))
+             .select_all(:posts)
              .distinct
     end
   end
@@ -162,17 +161,49 @@ end
 posts.all # => [Post, ...]
 posts.first # => Post
 posts.count # => 1
+
 posts.where(id: [1,2]) # => [Post, ...]
 posts.where{id > 1}.limit(10).offset(20) } # => [Post, ...]
-posts.graph(:user, :categories, 'comments.user') # => [Post(User, [Categories, ...], [Comments(User)]), ...]
-posts.created_by(1) # => [Post, ...]
-posts.created_by(1).entitled('...').commented_by(2) # => [Post, ...]
-posts.with_categories([1,2]) # => [Post, ...]
+
 posts.where(id: [1,2]).raw # => [{id:1, ...}, {id:2, ...}]
 posts.where(id: [1,2]).primary_keys # => [1,2]
 posts.where(id: [1,2]).pluck(:id) # => [1,2]
 posts.where(id: [1,2]).pluck(:id, :title) # => [[1, ...], [2, ...]]
+
+posts.created_by(1) # => [Post, ...]
+posts.created_by(1).entitled('...').commented_by(2) # => [Post, ...]
+posts.with_categories([1,2]) # => [Post, ...]
+
+posts.graph(:user, :categories, 'comments.user') # => [Post(User, [Categories, ...], [Comments(User)]), ...]
+
 posts.join(:user).where(name: 'User 4') # => [Post, ...]
+
+posts.select_attributes(:id, :title) # => [Post, ...]
+posts.exclude_attributes(:id, :title) # => [Post, ...]
+posts.all_attributes # => [Post, ...]
+
+posts.graph('user.person').select_graph_attributes(user: [:id], 'user.person': [:last_name, :user_id]) # => [Post, ...]
+posts.graph('user.person').exclude_graph_attributes(user: [:name], 'user.person': [:first_name, :last_name]) # => [Post, ...]
+posts.graph('user.person').all_graph_attributes('user.person') # => [Post, ...]
+```
+### Natural Query Language
+
+```ruby
+posts.nql('id = 1') # => Equal
+posts.nql('id != 1') # => Not equal
+posts.nql('title: My post') # => Include
+posts.nql('title !: My post') # => Not include
+posts.nql('title ~ My post') # => Insensitive like
+posts.nql('id > 1') # => Greater
+posts.nql('id >= 1') # => Greater or equal
+posts.nql('id < 10') # => Less
+posts.nql('id <= 10') # => Less or equal
+
+posts.nql('id = 1 | id = 2') # => Or
+posts.nql('id > 1 & title: "My post"') # => And
+posts.nql('(id > 3 & id < 10) | title: "My post"') # => Precedence
+
+posts.nql('comments.user.person.document_number = 7') # => Nested
 ```
 
 ## Development

data/lib/rasti/db/collection.rb

@@ -2,9 +2,8 @@ module Rasti
   module DB
     class Collection
 
-      QUERY_METHODS = (Query::DATASET_CHAINED_METHODS + [:graph, :join, :count, :all, :each, :first, :pluck, :primary_keys, :any?, :empty?, :raw, :nql]).freeze
+      QUERY_METHODS = Query.public_instance_methods - Object.public_instance_methods
 
-      include Enumerable
       include Helpers::WithSchema
 
       class << self
@@ -16,8 +15,8 @@ module Rasti
           @collection_name ||= underscore(demodulize(name)).to_sym
         end
 
-        def collection_fields
-          @collection_fields ||= model.attributes - relations.keys
+        def collection_attributes
+          @collection_attributes ||= model.attributes - relations.keys
         end
 
         def primary_key
@@ -80,7 +79,7 @@ module Rasti
           queries[name] = lambda || block
           
           define_method name do |*args|
-            query.instance_exec(*args, &self.class.queries[name])
+            default_query.instance_exec(*args, &self.class.queries.fetch(name))
           end
         end
 
@@ -93,6 +92,12 @@ module Rasti
         @schema = schema ? schema.to_sym : nil
       end
 
+      QUERY_METHODS.each do |method|
+        define_method method do |*args, &block|
+          default_query.public_send method, *args, &block
+        end
+      end
+
       def dataset
         db[qualified_collection_name]
       end
@@ -172,12 +177,6 @@ module Rasti
         where(self.class.primary_key => primary_key).graph(*relations).first
       end
 
-      QUERY_METHODS.each do |method|
-        define_method method do |*args, &block|
-          query.public_send method, *args, &block
-        end
-      end
-
       def exists?(filter=nil, &block)
         build_query(filter, &block).any?
       end
@@ -199,16 +198,19 @@ module Rasti
         schema.nil? ? Sequel[self.class.collection_name] : Sequel[schema][self.class.collection_name]
       end
       
-      def query
-        Query.new self.class, dataset, [], schema
+      def default_query
+        Query.new collection_class: self.class, 
+                  dataset: dataset.select_all(self.class.collection_name), 
+                  schema: schema
       end
 
       def build_query(filter=nil, &block)
         raise ArgumentError, 'must specify filter hash or block' if filter.nil? && block.nil?
+        
         if filter
-          query.where filter
+          default_query.where filter
         else
-          block.arity == 0 ? query.instance_eval(&block) : block.call(query)
+          block.arity == 0 ? default_query.instance_eval(&block) : block.call(default_query)
         end
       end
 

data/lib/rasti/db/query.rb

@@ -7,19 +7,25 @@ module Rasti
       include Enumerable
       include Helpers::WithSchema
 
-      def initialize(collection_class, dataset, relations=[], schema=nil)
+      def initialize(collection_class:, dataset:, relations_graph:nil, schema:nil)
         @collection_class = collection_class
         @dataset = dataset
-        @relations = relations
+        @relations_graph = relations_graph || Relations::Graph.new(dataset.db, schema, collection_class)
         @schema = schema
       end
 
+      DATASET_CHAINED_METHODS.each do |method|
+        define_method method do |*args, &block|
+          build_query dataset: dataset.public_send(method, *args, &block)
+        end
+      end
+
       def raw
         dataset.all
       end
 
       def pluck(*attributes)
-        ds = dataset.select(*attributes.map { |attr| Sequel[collection_class.collection_name][attr] })
+        ds = dataset.select(*attributes.map { |a| Sequel[collection_class.collection_name][a] })
         attributes.count == 1 ? ds.map { |r| r[attributes.first] } : ds.map(&:values)
       end
 
@@ -27,6 +33,31 @@ module Rasti
         pluck collection_class.primary_key
       end
 
+      def select_attributes(*attributes)
+        build_query dataset: dataset.select(*attributes.map { |a| Sequel[collection_class.collection_name][a] })
+      end
+
+      def exclude_attributes(*excluded_attributes)
+        attributes = collection_class.collection_attributes - excluded_attributes
+        select_attributes(*attributes)
+      end
+
+      def all_attributes
+        build_query dataset: dataset.select_all(collection_class.collection_name)
+      end
+
+      def select_graph_attributes(selected_attributes)
+        build_query relations_graph: relations_graph.merge(selected_attributes: selected_attributes)
+      end
+
+      def exclude_graph_attributes(excluded_attributes)
+        build_query relations_graph: relations_graph.merge(excluded_attributes: excluded_attributes)
+      end
+
+      def all_graph_attributes(*relations)
+        build_query relations_graph: relations_graph.with_all_attributes_for(relations)
+      end
+
       def all
         with_graph(dataset.all).map do |row| 
           collection_class.model.new row
@@ -38,27 +69,18 @@ module Rasti
         all.each(&block)
       end
 
-      DATASET_CHAINED_METHODS.each do |method|
-        define_method method do |*args, &block|
-          Query.new collection_class, 
-                    dataset.public_send(method, *args, &block), 
-                    relations, 
-                    schema
-        end
-      end
-
-      def graph(*rels)
-        Query.new collection_class, 
-                  dataset, 
-                  (relations | rels), 
-                  schema
+      def graph(*relations)
+        build_query relations_graph: relations_graph.merge(relations: relations)
       end
 
-      def join(*rels)
-        Query.new collection_class, 
-                  Relations::GraphBuilder.joins_to(dataset, rels, collection_class, schema), 
-                  relations, 
-                  schema
+      def join(*relations)
+        graph = Relations::Graph.new dataset.db, schema, collection_class, relations
+        
+        ds = graph.add_joins(dataset)
+                  .distinct
+                  .select_all(collection_class.collection_name)
+        
+        build_query dataset: ds
       end
 
       def count
@@ -105,25 +127,41 @@ module Rasti
 
       private
 
+      attr_reader :collection_class, :dataset, :relations_graph, :schema
+
+      def build_query(**args)
+        current_args = {
+          collection_class: collection_class,
+          dataset: dataset,
+          relations_graph: relations_graph,
+          schema: schema
+        }
+
+        Query.new(**current_args.merge(args))
+      end
+
       def chainable(&block)
-        ds = instance_eval(&block)
-        Query.new collection_class, ds, relations, schema
+        build_query dataset: instance_eval(&block)
       end
 
       def with_related(relation_name, primary_keys)
         ds = collection_class.relations[relation_name].apply_filter dataset, schema, primary_keys
-        Query.new collection_class, ds, relations, schema
+        build_query dataset: ds
       end
 
       def with_graph(data)
         rows = data.is_a?(Array) ? data : [data]
-        Relations::GraphBuilder.graph_to rows, relations, collection_class, dataset.db, schema
+        relations_graph.fetch_graph rows
         data
       end
 
+      def nql_parser
+        NQL::SyntaxParser.new
+      end
+
       def method_missing(method, *args, &block)
-        if collection_class.queries.key?(method)
-          instance_exec(*args, &collection_class.queries[method])
+        if collection_class.queries.key? method
+          instance_exec(*args, &collection_class.queries.fetch(method))
         else
           super
         end
@@ -133,12 +171,6 @@ module Rasti
         collection_class.queries.key?(method) || super
       end
 
-      def nql_parser
-        NQL::SyntaxParser.new
-      end
-
-      attr_reader :collection_class, :dataset, :relations, :schema
-
     end
   end
 end

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

@@ -0,0 +1,135 @@
+module Rasti
+  module DB
+    module Relations
+      class Graph
+
+        def initialize(db, schema, collection_class, relations=[], selected_attributes={}, excluded_attributes={})
+          @db = db
+          @schema = schema
+          @collection_class = collection_class
+          @graph = build_graph relations, 
+                               Hash::Indifferent.new(selected_attributes), 
+                               Hash::Indifferent.new(excluded_attributes)
+        end
+
+        def merge(relations:[], selected_attributes:{}, excluded_attributes:{})
+          Graph.new db, 
+                    schema, 
+                    collection_class, 
+                    (flat_relations | relations), 
+                    flat_selected_attributes.merge(selected_attributes),
+                    flat_excluded_attributes.merge(excluded_attributes)
+        end
+
+        def with_all_attributes_for(relations)
+          relations_with_all_attributes = relations.map { |r| [r, nil] }.to_h
+
+          merge selected_attributes: relations_with_all_attributes, 
+                excluded_attributes: relations_with_all_attributes
+        end
+
+        def apply_to(query)
+          query.graph(*flat_relations)
+               .select_graph_attributes(flat_selected_attributes)
+               .exclude_graph_attributes(flat_excluded_attributes)
+        end
+
+        def fetch_graph(rows)
+          return if rows.empty?
+
+          graph.roots.each do |node|
+            relation_of(node).fetch_graph rows, 
+                                          db, 
+                                          schema, 
+                                          node[:selected_attributes],
+                                          node[:excluded_attributes] ,
+                                          subgraph_of(node)
+          end
+        end
+
+        def add_joins(dataset, prefix=nil)
+          graph.roots.each do |node|
+            relation = relation_of node
+            dataset = relation.add_join dataset, schema, prefix
+            dataset = subgraph_of(node).add_joins dataset, relation.join_relation_name(prefix)
+          end
+
+          dataset
+        end
+
+        private
+
+        attr_reader :db, :schema, :collection_class, :graph
+
+        def relation_of(node)
+          collection_class.relations.fetch(node[:name])
+        end
+
+        def flat_relations
+          graph.map(&:id)
+        end
+
+        def flat_selected_attributes
+          graph.each_with_object(Hash::Indifferent.new) do |node, hash|
+            hash[node.id] = node[:selected_attributes]
+          end
+        end
+
+        def flat_excluded_attributes
+          graph.each_with_object(Hash::Indifferent.new) do |node, hash|
+            hash[node.id] = node[:excluded_attributes]
+          end
+        end
+
+        def subgraph_of(node)
+          relations = []
+          selected = Hash::Indifferent.new
+          excluded = 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]
+          end
+
+          Graph.new db, 
+                    schema, 
+                    relation_of(node).target_collection_class, 
+                    relations, 
+                    selected, 
+                    excluded
+        end
+
+        def build_graph(relations, selected_attributes, excluded_attributes)
+          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]
+              
+              if sections.count > 1
+                parent_id = sections[0..-2].join('.')
+                graph.add_relation parent_id: parent_id, 
+                                   child_id: relation
+              end
+            end
+          end
+        end
+
+        def flatten(relations)
+          relations.flat_map do |relation|
+            parents = []
+            relation.to_s.split('.').map do |section|
+              parents << section
+              parents.compact.join('.')
+            end
+          end.uniq.sort
+        end
+
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module Rasti
           schema.nil? ? Sequel[relation_collection_name] : Sequel[schema][relation_collection_name]
         end
 
-        def graph_to(rows, db, schema=nil, relations=[])
+        def fetch_graph(rows, db, schema=nil, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
           pks = rows.map { |row| row[source_collection_class.primary_key] }
 
           target_collection = target_collection_class.new db, schema
@@ -29,11 +29,11 @@ module Rasti
           join_rows = target_collection.dataset
                                        .join(relation_name, target_foreign_key => target_collection_class.primary_key)
                                        .where(Sequel[relation_name][source_foreign_key] => pks)
-                                       .select_all(qualified_target_collection_name(schema))
+                                       .select_all(target_collection_class.collection_name)
                                        .select_append(Sequel[relation_name][source_foreign_key].as(:source_foreign_key))
                                        .all
 
-          GraphBuilder.graph_to join_rows, relations, target_collection_class, db, schema
+          relations_graph.fetch_graph join_rows if relations_graph
 
           relation_rows = join_rows.each_with_object(Hash.new { |h,k| h[k] = [] }) do |row, hash| 
             attributes = row.select { |attr,_| target_collection_class.model.attributes.include? attr }
@@ -45,7 +45,7 @@ module Rasti
           end
         end
 
-        def join_to(dataset, schema=nil, prefix=nil)
+        def add_join(dataset, schema=nil, prefix=nil)
           many_to_many_relation_alias = with_prefix prefix, "#{relation_collection_name}_#{SecureRandom.base64}"
 
           qualified_relation_source = prefix ? Sequel[prefix] : qualified_source_collection_name(schema)
@@ -69,7 +69,7 @@ module Rasti
 
           dataset.join(relation_name, source_foreign_key => target_collection_class.primary_key)
                  .where(Sequel[relation_name][target_foreign_key] => primary_keys)
-                 .select_all(qualified_source_collection_name(schema))
+                 .select_all(source_collection_class.collection_name)
                  .distinct
         end
 

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

@@ -7,23 +7,26 @@ module Rasti
           @foreign_key ||= options[:foreign_key] || target_collection_class.foreign_key
         end
 
-        def graph_to(rows, db, schema=nil, relations=[])
+        def fetch_graph(rows, db, schema=nil, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
           fks = rows.map { |row| row[foreign_key] }.uniq
 
           target_collection = target_collection_class.new db, schema
 
-          relation_rows = target_collection.where(source_collection_class.primary_key => fks)
-                                           .graph(*relations)
-                                           .each_with_object({}) do |row, hash| 
-                                              hash[row.public_send(source_collection_class.primary_key)] = row
-                                            end
+          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 = relations_graph.apply_to query if relations_graph
+
+          relation_rows = query.each_with_object({}) do |row, hash| 
+            hash[row.public_send(source_collection_class.primary_key)] = row
+          end
           
           rows.each do |row| 
             row[name] = relation_rows[row[foreign_key]]
           end
         end
 
-        def join_to(dataset, schema=nil, prefix=nil)
+        def add_join(dataset, schema=nil, prefix=nil)
           relation_alias = join_relation_name prefix
 
           qualified_relation_source = prefix ? Sequel[prefix] : qualified_source_collection_name(schema)

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

@@ -7,21 +7,24 @@ module Rasti
           @foreign_key ||= options[:foreign_key] || source_collection_class.foreign_key
         end
 
-        def graph_to(rows, db, schema=nil, relations=[])
+        def fetch_graph(rows, db, schema=nil, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
           pks = rows.map { |row| row[source_collection_class.primary_key] }.uniq
 
           target_collection = target_collection_class.new db, schema
 
-          relation_rows = target_collection.where(foreign_key => pks)
-                                           .graph(*relations)
-                                           .group_by { |r| r.public_send(foreign_key) }
+          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 = relations_graph.apply_to query if relations_graph
+
+          relation_rows = query.group_by(&foreign_key)
 
           rows.each do |row| 
             row[name] = build_graph_result relation_rows.fetch(row[source_collection_class.primary_key], [])
           end
         end
 
-        def join_to(dataset, schema=nil, prefix=nil)
+        def add_join(dataset, schema=nil, prefix=nil)
           relation_alias = join_relation_name prefix
 
           qualified_relation_source = prefix ? Sequel[prefix] : qualified_source_collection_name(schema)

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '1.4.0'
+    VERSION = '1.5.0'
   end
 end

data/lib/rasti/db.rb

@@ -3,7 +3,9 @@ require 'consty'
 require 'time'
 require 'timing'
 require 'treetop'
+require 'hierarchical_graph'
 require 'class_config'
+require 'hash_ext'
 require 'multi_require'
 
 module Rasti

data/rasti-db.gemspec

@@ -24,8 +24,10 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'timing', '~> 0.1', '>= 0.1.3'
   spec.add_runtime_dependency 'class_config', '~> 0.0', '>= 0.0.2'
   spec.add_runtime_dependency 'multi_require', '~> 1.0'
+  spec.add_runtime_dependency 'hierarchical_graph', '~> 1.0'
+  spec.add_runtime_dependency 'hash_ext', '~> 0.5'
 
-  spec.add_development_dependency 'rake', '~> 11.0'
+  spec.add_development_dependency 'rake', '~> 12.3'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'
   spec.add_development_dependency 'minitest-colorin', '~> 0.1'
   spec.add_development_dependency 'minitest-line', '~> 0.6'
@@ -38,10 +40,4 @@ Gem::Specification.new do |spec|
   else
     spec.add_development_dependency 'sqlite3', '~> 1.3'
   end
-
-  if RUBY_VERSION < '2'
-    spec.add_development_dependency 'term-ansicolor', '~> 1.3.0'
-    spec.add_development_dependency 'tins', '~> 1.6.0'
-    spec.add_development_dependency 'json', '~> 1.8'
-  end
 end

data/spec/collection_spec.rb

@@ -6,7 +6,7 @@ describe 'Collection' do
 
     it 'Implicit' do
       Users.collection_name.must_equal :users
-      Users.collection_fields.must_equal [:id, :name]
+      Users.collection_attributes.must_equal [:id, :name]
       Users.model.must_equal User
       Users.primary_key.must_equal :id
       Users.foreign_key.must_equal :user_id
@@ -14,7 +14,7 @@ describe 'Collection' do
 
     it 'Explicit' do
       People.collection_name.must_equal :people
-      People.collection_fields.must_equal [:document_number, :first_name, :last_name, :birth_date, :user_id]
+      People.collection_attributes.must_equal [:document_number, :first_name, :last_name, :birth_date, :user_id]
       People.model.must_equal Person
       People.primary_key.must_equal :document_number
       People.foreign_key.must_equal :document_number
@@ -244,6 +244,24 @@ describe 'Collection' do
       users.find_graph(user_id, :posts).must_equal User.new id: user_id, name: 'User 1', posts: posts.all
     end
 
+    it 'Select attributes' do
+      id = db[:users].insert name: 'User 1'
+
+      users.select_attributes(:id).all.must_equal [User.new(id: id)]
+    end
+
+    it 'Exclude attributes' do
+      db[:users].insert name: 'User 1'
+
+      users.exclude_attributes(:id).all.must_equal [User.new(name: 'User 1')]
+    end
+
+    it 'All attributes' do
+      id = db[:users].insert name: 'User 1'
+
+      users.select_attributes(:id).all_attributes.all.must_equal [User.new(id: id, name: 'User 1')]
+    end
+
     it 'Count' do
       1.upto(10) { |i| db[:users].insert name: "User #{i}" }
 
@@ -430,21 +448,21 @@ describe 'Collection' do
       stubs = Proc.new do |sql|
         case sql
 
-        when 'SELECT * FROM custom_schema.users', 
-             'SELECT * FROM custom_schema.users WHERE (id IN (2, 1))'
+        when 'SELECT users.* FROM custom_schema.users', 
+             'SELECT users.* FROM custom_schema.users WHERE (id IN (2, 1))'
           [
             {id: 1},
             {id: 2}
           ]
 
-        when 'SELECT * FROM custom_schema.posts',
-             'SELECT * FROM custom_schema.posts WHERE (user_id IN (1, 2))'
+        when 'SELECT posts.* FROM custom_schema.posts',
+             'SELECT posts.* FROM custom_schema.posts WHERE (user_id IN (1, 2))'
           [
             {id: 3, user_id: 1},
             {id: 4, user_id: 2}
           ]
 
-        when 'SELECT * FROM custom_schema.comments WHERE (post_id IN (3, 4))'
+        when 'SELECT comments.* FROM custom_schema.comments WHERE (post_id IN (3, 4))'
           [
             {id: 5, user_id: 2, post_id: 3},
             {id: 6, user_id: 1, post_id: 3},
@@ -506,33 +524,34 @@ describe 'Collection' do
 
     it 'Chained query' do
       stub_users.where(id: [1,2]).limit(1).order(:name).all
-      stub_db.sqls.must_equal ['SELECT * FROM custom_schema.users WHERE (id IN (1, 2)) ORDER BY name LIMIT 1']
+      stub_db.sqls.must_equal ['SELECT users.* FROM custom_schema.users WHERE (id IN (1, 2)) ORDER BY name LIMIT 1']
     end
 
     it 'Graph' do
       stub_posts.graph(:user, :categories, 'comments.user.posts.categories').all
+
       stub_db.sqls.must_equal [
-        'SELECT * FROM custom_schema.posts',
-        'SELECT * FROM custom_schema.users WHERE (id IN (1, 2))',
-        'SELECT custom_schema.categories.*, custom_schema.categories_posts.post_id AS source_foreign_key FROM custom_schema.categories INNER JOIN custom_schema.categories_posts ON (custom_schema.categories_posts.category_id = custom_schema.categories.id) WHERE (custom_schema.categories_posts.post_id IN (3, 4))', 
-        'SELECT * FROM custom_schema.comments WHERE (post_id IN (3, 4))',
-        'SELECT * FROM custom_schema.users WHERE (id IN (2, 1))',
-        'SELECT * FROM custom_schema.posts WHERE (user_id IN (1, 2))',
-        'SELECT custom_schema.categories.*, custom_schema.categories_posts.post_id AS source_foreign_key FROM custom_schema.categories INNER JOIN custom_schema.categories_posts ON (custom_schema.categories_posts.category_id = custom_schema.categories.id) WHERE (custom_schema.categories_posts.post_id IN (3, 4))'
+        'SELECT posts.* FROM custom_schema.posts',
+        'SELECT categories.*, custom_schema.categories_posts.post_id AS source_foreign_key FROM custom_schema.categories INNER JOIN custom_schema.categories_posts ON (custom_schema.categories_posts.category_id = custom_schema.categories.id) WHERE (custom_schema.categories_posts.post_id IN (3, 4))', 
+        'SELECT comments.* FROM custom_schema.comments WHERE (post_id IN (3, 4))',
+        'SELECT users.* FROM custom_schema.users WHERE (id IN (2, 1))',
+        'SELECT posts.* FROM custom_schema.posts WHERE (user_id IN (1, 2))',
+        'SELECT categories.*, custom_schema.categories_posts.post_id AS source_foreign_key FROM custom_schema.categories INNER JOIN custom_schema.categories_posts ON (custom_schema.categories_posts.category_id = custom_schema.categories.id) WHERE (custom_schema.categories_posts.post_id IN (3, 4))',
+        'SELECT users.* FROM custom_schema.users WHERE (id IN (1, 2))'
       ]
     end
 
     it 'Named query' do
       stub_posts.commented_by(1).all
       stub_db.sqls.must_equal [
-        'SELECT DISTINCT custom_schema.posts.* FROM custom_schema.posts INNER JOIN custom_schema.comments ON (custom_schema.comments.post_id = custom_schema.posts.id) WHERE (custom_schema.comments.user_id = 1)'
+        'SELECT DISTINCT posts.* FROM custom_schema.posts INNER JOIN custom_schema.comments ON (custom_schema.comments.post_id = custom_schema.posts.id) WHERE (custom_schema.comments.user_id = 1)'
       ]
     end
 
     it 'Custom query' do
       stub_comments.posts_commented_by(2)
       stub_db.sqls.must_equal [
-        'SELECT custom_schema.posts.* FROM custom_schema.comments INNER JOIN custom_schema.posts ON (custom_schema.posts.id = custom_schema.comments.post_id) WHERE (comments.user_id = 2)'
+        'SELECT posts.* FROM custom_schema.comments INNER JOIN custom_schema.posts ON (custom_schema.posts.id = custom_schema.comments.post_id) WHERE (comments.user_id = 2)'
       ]
     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'
@@ -40,7 +41,7 @@ class Posts < Rasti::DB::Collection
     chainable do
       dataset.join(with_schema(:comments), post_id: :id)
              .where(with_schema(:comments, :user_id) => user_id)
-             .select_all(with_schema(:posts))
+             .select_all(:posts)
              .distinct
     end
   end
@@ -53,7 +54,7 @@ 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))
+           .select_all(:posts)
            .map { |row| Post.new row }
   end
 end

data/spec/query_spec.rb

@@ -3,18 +3,38 @@ require 'minitest_helper'
 describe 'Query' do
 
   before do
-    1.upto(10) { |i| db[:users].insert name: "User #{i}" }
+    1.upto(10) do |i| 
+      db[:users].insert name: "User #{i}"
+
+      db[:people].insert user_id: i, 
+                         document_number: i, 
+                         first_name: "Name #{i}", 
+                         last_name: "Last Name #{i}", 
+                         birth_date: Time.now
+    end
 
     db[:posts].insert user_id: 2, title: 'Sample post', body: '...'
     db[:posts].insert user_id: 1, title: 'Another post', body: '...'
     db[:posts].insert user_id: 4, title: 'Best post', body: '...'
-  end
 
-  let(:users_query) { Rasti::DB::Query.new Users, db[:users] }
+    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(:posts_query) { Rasti::DB::Query.new Posts, db[:posts] }
+  let(:users_query) { Rasti::DB::Query.new collection_class: Users, dataset: db[:users] }
+  
+  let(:posts_query) { Rasti::DB::Query.new collection_class: Posts, dataset: db[:posts] }
   
-  let(:comments_query) { Rasti::DB::Query.new Comments, db[:comments] }
+  let(:comments_query) { Rasti::DB::Query.new collection_class: Comments, dataset: db[:comments] }
 
   it 'Count' do
     users_query.count.must_equal 10
@@ -37,6 +57,61 @@ 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).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
+    person = Person.new db[:people].where(document_number: 2).select(:first_name, :last_name, :user_id).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')
+               .select_graph_attributes(user: [:id], 'user.person' => [:first_name, :last_name, :user_id])
+               .all
+               .must_equal [post]
+  end
+  
+  it 'Exclude graph attributes' do
+    person = Person.new db[:people].where(document_number: 2).select(:document_number, :last_name, :user_id).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' => [:first_name, :birth_date])
+               .all
+               .must_equal [post]
+  end
+  
+  it 'All graph attributes' do
+    person = Person.new db[:people].where(document_number: 2).first
+
+    user = User.new db[:users].where(id: 2).select(:id).first.merge(person: person)
+
+    post = Post.new db[:posts].where(id: 1).first.merge(user: user)
+
+    posts_query.where(id: 1)
+               .graph('user.person')
+               .exclude_graph_attributes(user: [:name], 'user.person' => [:birth_date, :first_name, :last_name])
+               .all_graph_attributes('user.person')
+               .all
+               .must_equal [post]
+  end
+
   it 'Map' do
     users_query.map(&:name).must_equal db[:users].map(:name)
   end
@@ -96,12 +171,14 @@ describe 'Query' 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: '...')])
   end
 
-  it 'Empty?' do
+  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
@@ -126,28 +203,6 @@ 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')]
     end
@@ -179,55 +234,37 @@ describe 'Query' do
 
   describe 'NQL' 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 'Invalid expression' do
       error = proc { posts_query.nql('a + b') }.must_raise Rasti::DB::NQL::InvalidExpressionError
       error.message.must_equal 'Invalid filter expression: a + b'
     end
     
     it 'Filter to self table' do
-      people_query = Rasti::DB::Query.new People, db[:people]
-
-      people_query.nql('user_id > 7')
-                  .map(&:user_id)
-                  .sort
-                  .must_equal [8, 9, 10]
+      posts_query.nql('user_id > 1')
+                 .pluck(:user_id)
+                 .sort
+                 .must_equal [2, 4]
     end
 
     it 'Filter to join table' do
       posts_query.nql('categories.name = Category 2')
-                 .map(&:id)
+                 .pluck(:id)
                  .sort
                  .must_equal [1, 2]
     end
 
     it 'Filter to 2nd order relation' do
       posts_query.nql('comments.user.person.document_number = 7')
-                 .map(&:id)
+                 .pluck(:id)
                  .must_equal [1]
     end
 
+    it 'Filter combined' do
+      posts_query.nql('(categories.id = 1 | categories.id = 3) & comments.user.person.document_number = 2')
+                 .pluck(:id)
+                 .must_equal [2]
+    end
+
   end
 
 end

data/spec/relations_spec.rb

@@ -37,7 +37,7 @@ describe 'Relations' do
       1.upto(2) { |i| db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...' }
       rows = db[:users].all
       
-      Users.relations[:posts].graph_to rows, db
+      Users.relations[:posts].fetch_graph rows, db
       
       rows[0][:posts].must_equal posts.where(user_id: user_id).all
     end
@@ -79,7 +79,7 @@ describe 'Relations' do
       db[:posts].insert user_id: user_id, title: 'Post 1', body: '...'
       rows = db[:posts].all
 
-      Posts.relations[:user].graph_to rows, db
+      Posts.relations[:user].fetch_graph rows, db
 
       rows[0][:user].must_equal users.first
     end
@@ -136,7 +136,7 @@ describe 'Relations' do
 
       rows = db[:posts].all
 
-      Posts.relations[:categories].graph_to rows, db
+      Posts.relations[:categories].fetch_graph rows, db
 
       rows[0][:categories].must_equal categories.where(id: [1,2]).all
       rows[1][:categories].must_equal categories.where(id: [3,4]).all
@@ -186,7 +186,7 @@ describe 'Relations' do
 
       rows = db[:users].all
 
-      Users.relations[:person].graph_to rows, db
+      Users.relations[:person].fetch_graph rows, db
 
       2.times do |i|
         rows[i][:person].must_equal people.find("document_#{i}")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasti-db
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Gabriel Naiman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-08 00:00:00.000000000 Z
+date: 2020-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -112,20 +112,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: hierarchical_graph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: hash_ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -279,7 +307,7 @@ files:
 - lib/rasti/db/nql/syntax.treetop
 - lib/rasti/db/query.rb
 - lib/rasti/db/relations/base.rb
-- lib/rasti/db/relations/graph_builder.rb
+- lib/rasti/db/relations/graph.rb
 - lib/rasti/db/relations/many_to_many.rb
 - lib/rasti/db/relations/many_to_one.rb
 - lib/rasti/db/relations/one_to_many.rb

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

@@ -1,60 +0,0 @@
-module Rasti
-  module DB
-    module Relations
-      class GraphBuilder
-        class << self
-
-          def graph_to(rows, relations, collection_class, db, schema=nil)
-            return if rows.empty?
-
-            parse(relations).each do |relation_name, nested_relations|
-              relation = get_relation collection_class, relation_name
-              relation.graph_to rows, db, schema, nested_relations
-            end
-          end
-
-          def joins_to(dataset, relations, collection_class, schema=nil)
-            ds = recursive_joins dataset, recursive_parse(relations), collection_class, schema
-            qualified_collection_name = schema ? Sequel[schema][collection_class.collection_name] : Sequel[collection_class.collection_name]
-            ds.distinct.select_all(qualified_collection_name)
-          end
-
-          private
-
-          def get_relation(collection_class, relation_name)
-            raise "Undefined relation #{relation_name} for #{collection_class}" unless collection_class.relations.key? relation_name
-            collection_class.relations[relation_name]
-          end
-
-          def parse(relations)
-            relations.each_with_object({}) do |relation, hash|
-              tail = relation.to_s.split '.'
-              head = tail.shift.to_sym
-              hash[head] ||= []
-              hash[head] << tail.join('.') unless tail.empty?
-            end
-          end
-
-          def recursive_parse(relations)
-            parse(relations).each_with_object({}) do |(key, value), hash|
-              hash[key] = recursive_parse value
-            end
-          end
-
-          def recursive_joins(dataset, joins, collection_class, schema, prefix=nil)
-            joins.each do |relation_name, nested_joins|
-              relation = get_relation collection_class, relation_name
-
-              dataset = relation.join_to dataset, schema, prefix
-
-              dataset = recursive_joins dataset, nested_joins, relation.target_collection_class, schema, relation.join_relation_name(prefix) unless nested_joins.empty?
-            end
-
-            dataset
-          end
-
-        end
-      end
-    end
-  end
-end