rasti-db 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01b5188397b357e5b8414eebd556115131bb8c46
-  data.tar.gz: 84d1beb743f8a8ff07247724013bb8c0f9394ede
+  metadata.gz: 3f0307b5b603e80d0dad4b261c1fa3a47c0f0266
+  data.tar.gz: 6c511dc77b55344abe59dcdddfcccf303cced89d
 SHA512:
-  metadata.gz: 10563c028636028583d1205b0c999ad82e5281180ba16367442b1f5804510b09184db8930145e9937e2a82e675879aa9f56a8eea8f399ab6346eb6f40a6df1eb
-  data.tar.gz: a8ba4affb905f24c39cfab601b51cd263ccf2ab3c34c22494e4fc53475e96530e73df7e2759af381e7d1f2f288b2f168408432138a37042b40823a1697c64a46
+  metadata.gz: b6d538a0b19fc8fe8f9d86bd94c4bceae526be7894e2045f61239b1378f40ba07512d970071bfec613abe045373246fedbc837d871107f32523f65e2aaa27f81
+  data.tar.gz: 83bf69890058e2da151cc3d5429e63c8374ea816b1ce9e28d2f9780c3129a7cb7940055bebcf258c191ae4d9e82f763f940d2eca3d45a3f2479efcd529eaabc2

data/README.md

@@ -172,6 +172,7 @@ 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.join(:user).where(name: 'User 4') # => [Post, ...]
 ```
 
 ## Contributing

data/lib/rasti/db/collection.rb

@@ -2,7 +2,7 @@ module Rasti
   module DB
     class Collection
 
-      QUERY_METHODS = (Query::DATASET_CHAINED_METHODS + [:graph, :count, :all, :each, :first, :pluck, :primary_keys, :any?, :empty?, :raw]).freeze
+      QUERY_METHODS = (Query::DATASET_CHAINED_METHODS + [:graph, :join, :count, :all, :each, :first, :pluck, :primary_keys, :any?, :empty?, :raw]).freeze
 
       include Enumerable
       include Helpers::WithSchema
@@ -192,7 +192,7 @@ module Rasti
       end
 
       def qualified_collection_name
-        schema.nil? ? self.class.collection_name : Sequel.qualify(schema, self.class.collection_name)
+        schema.nil? ? Sequel[self.class.collection_name] : Sequel[schema][self.class.collection_name]
       end
       
       def query

data/lib/rasti/db/helpers.rb

@@ -1,18 +1,16 @@
 module Rasti
   module DB
     module Helpers
-    
       module WithSchema
 
         private
 
         def with_schema(table, field=nil)
-          qualified_table = schema ? Sequel.qualify(schema, table) : table
+          qualified_table = schema ? Sequel[schema][table] : Sequel[table]
           field ? Sequel[qualified_table][field] : qualified_table
         end
 
       end
-
     end
   end
 end

data/lib/rasti/db/query.rb

@@ -19,7 +19,7 @@ module Rasti
       end
 
       def pluck(*attributes)
-        ds = dataset.select(*attributes.map { |attr| Sequel.qualify(collection_class.collection_name, attr) })
+        ds = dataset.select(*attributes.map { |attr| Sequel[collection_class.collection_name][attr] })
         attributes.count == 1 ? ds.map { |r| r[attributes.first] } : ds.map(&:values)
       end
 
@@ -54,6 +54,13 @@ module Rasti
                   schema
       end
 
+      def join(*rels)
+        Query.new collection_class, 
+                  Relations::GraphBuilder.joins_to(dataset, rels, collection_class, schema), 
+                  relations, 
+                  schema
+      end
+
       def count
         dataset.count
       end

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

@@ -33,16 +33,24 @@ module Rasti
           self.class == OneToOne
         end
 
+        def join_relation_name(prefix)
+          with_prefix prefix, name
+        end
+
         private
 
         attr_reader :options
 
         def qualified_source_collection_name(schema=nil)
-          schema.nil? ? source_collection_class.collection_name : Sequel.qualify(schema, source_collection_class.collection_name)
+          schema.nil? ? Sequel[source_collection_class.collection_name] : Sequel[schema][source_collection_class.collection_name]
         end
 
         def qualified_target_collection_name(schema=nil)
-          schema.nil? ? target_collection_class.collection_name : Sequel.qualify(schema, target_collection_class.collection_name)
+          schema.nil? ? Sequel[target_collection_class.collection_name] : Sequel[schema][target_collection_class.collection_name]
+        end
+
+        def with_prefix(prefix, name)
+          [prefix, name].compact.join('__').to_sym
         end
         
       end

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

@@ -7,14 +7,25 @@ module Rasti
           def graph_to(rows, relations, collection_class, db, schema=nil)
             return if rows.empty?
 
-            parse(relations).each do |relation, nested_relations|
-              raise "Undefined relation #{relation} for #{collection_class}" unless collection_class.relations.key? relation
-              collection_class.relations[relation].graph_to rows, db, schema, nested_relations
+            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 = recusrive_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 '.'
@@ -24,6 +35,24 @@ module Rasti
             end
           end
 
+          def recursive_parse(relations)
+            parse(relations).each_with_object({}) do |(key, value), hash|
+              hash[key] = recursive_parse value
+            end
+          end
+
+          def recusrive_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 = recusrive_joins dataset, nested_joins, relation.target_collection_class, schema, relation.join_relation_name(prefix) unless nested_joins.empty?
+            end
+
+            dataset
+          end
+
         end
       end
     end

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

@@ -16,7 +16,7 @@ module Rasti
         end
 
         def qualified_relation_collection_name(schema=nil)
-          schema.nil? ? relation_collection_name : Sequel.qualify(schema, relation_collection_name)
+          schema.nil? ? Sequel[relation_collection_name] : Sequel[schema][relation_collection_name]
         end
 
         def graph_to(rows, db, schema=nil, relations=[])
@@ -28,9 +28,9 @@ module Rasti
 
           join_rows = target_collection.dataset
                                        .join(relation_name, target_foreign_key => target_collection_class.primary_key)
-                                       .where(Sequel.qualify(relation_name, source_foreign_key) => pks)
+                                       .where(Sequel[relation_name][source_foreign_key] => pks)
                                        .select_all(qualified_target_collection_name(schema))
-                                       .select_append(Sequel.qualify(relation_name, source_foreign_key).as(:source_foreign_key))
+                                       .select_append(Sequel[relation_name][source_foreign_key].as(:source_foreign_key))
                                        .all
 
           GraphBuilder.graph_to join_rows, relations, target_collection_class, db, schema
@@ -45,11 +45,30 @@ module Rasti
           end
         end
 
+        def join_to(dataset, schema=nil, prefix=nil)
+          many_to_many_relation_alias = with_prefix prefix, relation_collection_name
+
+          qualified_relation_source = prefix ? Sequel[prefix] : qualified_source_collection_name(schema)
+
+          many_to_many_condition = {
+            Sequel[many_to_many_relation_alias][source_foreign_key] => qualified_relation_source[source_collection_class.primary_key]
+          }
+
+          relation_alias = join_relation_name prefix
+
+          relation_condition = {
+            Sequel[relation_alias][target_collection_class.primary_key] => Sequel[many_to_many_relation_alias][target_foreign_key]
+          }
+
+          dataset.join(qualified_relation_collection_name(schema).as(many_to_many_relation_alias), many_to_many_condition)
+                 .join(qualified_target_collection_name(schema).as(relation_alias), relation_condition)
+        end
+
         def apply_filter(dataset, schema=nil, primary_keys=[])
           relation_name = qualified_relation_collection_name schema
 
           dataset.join(relation_name, source_foreign_key => target_collection_class.primary_key)
-                 .where(Sequel.qualify(relation_name, target_foreign_key) => primary_keys)
+                 .where(Sequel[relation_name][target_foreign_key] => primary_keys)
                  .select_all(qualified_source_collection_name(schema))
                  .distinct
         end

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

@@ -23,6 +23,18 @@ module Rasti
           end
         end
 
+        def join_to(dataset, schema=nil, prefix=nil)
+          relation_alias = join_relation_name prefix
+
+          qualified_relation_source = prefix ? Sequel[prefix] : qualified_source_collection_name(schema)
+
+          relation_condition = {
+            Sequel[relation_alias][target_collection_class.primary_key] => qualified_relation_source[foreign_key]
+          }
+
+          dataset.join(qualified_target_collection_name(schema).as(relation_alias), relation_condition)
+        end
+
         def apply_filter(dataset, schema=nil, primary_keys=[])
           dataset.where(foreign_key => primary_keys)
         end

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

@@ -21,11 +21,23 @@ module Rasti
           end
         end
 
+        def join_to(dataset, schema=nil, prefix=nil)
+          relation_alias = join_relation_name prefix
+
+          qualified_relation_source = prefix ? Sequel[prefix] : qualified_source_collection_name(schema)
+
+          relation_condition = {
+            Sequel[relation_alias][foreign_key] => qualified_relation_source[source_collection_class.primary_key]
+          }
+
+          dataset.join(qualified_target_collection_name(schema).as(relation_alias), relation_condition)
+        end
+
         def apply_filter(dataset, schema=nil, primary_keys=[])
           target_name = qualified_target_collection_name schema
 
           dataset.join(target_name, foreign_key => source_collection_class.primary_key)
-                 .where(Sequel.qualify(target_name, target_collection_class.primary_key) => primary_keys)
+                 .where(Sequel[target_name][target_collection_class.primary_key] => primary_keys)
                  .select_all(qualified_source_collection_name(schema))
                  .distinct
         end

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '1.0.0'
+    VERSION = '1.1.0'
   end
 end

data/spec/query_spec.rb

@@ -4,6 +4,7 @@ describe 'Query' do
 
   before do
     1.upto(10) { |i| db[:users].insert name: "User #{i}" }
+
     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: '...'
@@ -123,4 +124,57 @@ describe 'Query' do
 
   end
 
+  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
+
+    it 'Many to One' do
+      posts_query.join(:user).where(name: 'User 4').all.must_equal [Post.new(id: 3, user_id: 4, title: 'Best post', body: '...')]
+    end
+
+    it 'One to One' do
+      users_query.join(:person).where(document_number: 1).all.must_equal [User.new(id: 1, name: 'User 1')]
+    end
+
+    it 'Many to Many' do
+      posts_query.join(:categories).where(name: 'Category 3').order(:id).all.must_equal [
+        Post.new(id: 2, user_id: 1, title: 'Another post', body: '...'),
+        Post.new(id: 3, user_id: 4, title: 'Best post', body: '...'),
+      ]
+    end
+
+    it 'Nested' do
+      posts_query.join('categories', 'comments.user.person')
+                 .where(Sequel[:categories][:name] => 'Category 2')
+                 .where(Sequel[:comments__user__person][:document_number] => 7)
+                 .all
+                 .must_equal [Post.new(id: 1, user_id: 2, title: 'Sample post', body: '...')]
+    end
+
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasti-db
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Gabriel Naiman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-21 00:00:00.000000000 Z
+date: 2019-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel