rasti-db 1.4.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed5332eda8adfde54d7465d8f3f631d9b542f54d17c78644703d2f9054cb1bca
-  data.tar.gz: 5452a867c32c4083f10149c3496093e731d6f8d64a6b13fafd57ebcc0d7e38c8
+  metadata.gz: d9da5c8d1c2a7912585a7b1f43e9f3ded9dc859e362ce071c692659e4f98b4ba
+  data.tar.gz: fa12eafca7db2b3b540871e8701218d3bb176a7cbd3b1c36d57b8fef4884064f
 SHA512:
-  metadata.gz: 31a039adaeb64c98fa7f5c38b2155a009f78e2a824d9c8d4e9969bd2d9ff7599afc899d5b10c3864694a22540061cf0f439f681792f2f89e9eb9da030aa7c28e
-  data.tar.gz: 393c7b91108ff8ab2c8effed2016b4ea912747baf65194c05614a01ef9d4d4447d41f350e996f0bdf8b14b9de102ced09bd023ce9cef590306068c28a8ae051c
+  metadata.gz: cd5dbacac1bf5afe377e2c3078691e8b77afed7c1fe0fa55a25e1c446f698c91630bb07045791d1aacaad45fef2967c27b2a316368083a4e27d0fd45f36c6955
+  data.tar.gz: 83a7a7048def925647078c13cfe241ca3f082cb0ab41a377d9d58fef69de1ffc06fcd781f62e51b7677bf3ffb1d60889a8d88941bc3e44c3127f656e1af720d9

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
 
@@ -29,49 +28,62 @@ Or install it yourself as:
 ### Database connection
 
 ```ruby
-DB = Sequel.connect ...
+DB_1 = Sequel.connect ...
+DB_2 = Sequel.connect ...
 ```
 
 ### Database schema
 
 ```ruby
-DB.create_table :users do
+DB_1.create_table :users do
   primary_key :id
   String :name, null: false, unique: true
 end
 
-DB.create_table :posts do
+DB_1.create_table :posts do
   primary_key :id
   String :title, null: false, unique: true
   String :body, null: false
+  Integer :language_id, null: false, index: true
   foreign_key :user_id, :users, null: false, index: true
 end
 
-DB.create_table :comments do
+DB_1.create_table :comments do
   primary_key :id
   String :text, null: false
   foreign_key :user_id, :users, null: false, index: true
   foreign_key :post_id, :posts, null: false, index: true
 end
 
-DB.create_table :categories do
+DB_1.create_table :categories do
   primary_key :id
   String :name, null: false, unique: true
 end
 
-DB.create_table :categories_posts do
+DB_1.create_table :categories_posts do
   foreign_key :category_id, :categories, null: false, index: true
   foreign_key :post_id, :posts, null: false, index: true
   primary_key [:category_id, :post_id]
 end
 
-DB.create_table :people do
+DB_1.create_table :people do
   String :document_number, null: false, primary_key: true
   String :first_name, null: false
   String :last_name, null: false
   Date :birth_date, null: false
   foreign_key :user_id, :users, null: false, unique: true
 end
+
+DB_1.create_table :languages_people do
+  Integer :language_id, null: false, index: true
+  foreign_key :document_number, :people, type: String, null: false, index: true
+  primary_key [:language_id, :document_number]
+end
+
+DB_2.create_table :languages do
+  primary_key :id
+  String :name, null: false, unique: true
+end
 ```
 
 ### Models
@@ -81,7 +93,8 @@ User     = Rasti::DB::Model[:id, :name, :posts, :comments, :person]
 Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories]
 Comment  = Rasti::DB::Model[:id, :text, :user_id, :user, :post_id, :post]
 Category = Rasti::DB::Model[:id, :name, :posts]
-Person   = Rasti::DB::Model[:document_number, :first_name, :last_name, :birth_date, :user_id, :user]
+Person   = Rasti::DB::Model[:document_number, :first_name, :last_name, :full_name, :birth_date, :user_id, :user]
+Language = Rasti::DB::Model[:id, :name, :people]
 ```
 
 ### Collections
@@ -98,17 +111,17 @@ class Posts < Rasti::DB::Collection
   many_to_many :categories
   one_to_many :comments
 
-  query :created_by do |user_id| 
+  query :created_by do |user_id|
     where user_id: user_id
   end
-  
+
   query :entitled, -> (title) { where title: title }
 
   query :commented_by do |user_id|
     chainable do
-      dataset.join(with_schema(:comments), post_id: :id)
-             .where(with_schema(:comments, :user_id) => user_id)
-             .select_all(with_schema(:posts))
+      dataset.join(qualify(:comments), post_id: :id)
+             .where(Sequel[:comments][:user_id] => user_id)
+             .select_all(:posts)
              .distinct
     end
   end
@@ -130,19 +143,34 @@ class People < Rasti::DB::Collection
   set_model Person
 
   many_to_one :user
+  many_to_many :languages
+
+  computed_attribute :full_name do
+    Rasti::DB::ComputedAttribute.new Sequel.join([:first_name, ' ', :last_name])
+  end
+end
+
+class Languages < Rasti::DB::Collection
+  set_data_source_name :other
+
+  one_to_many :posts
+  many_to_many :people, collection: People, relation_data_source_name: :default
 end
 
-users      = Users.new DB
-posts      = Posts.new DB
-comments   = Comments.new DB
-categories = Categories.new DB
-people     = People.new DB
+environment = Rasti::DB::Environment.new default: Rasti::DB::DataSource.new(DB_1),
+                                         other: Rasti::DB::DataSource.new(DB_2, 'custom_schema')
+
+users      = Users.new environment
+posts      = Posts.new environment
+comments   = Comments.new environment
+categories = Categories.new environment
+people     = People.new environment
 ```
 
 ### Persistence
 
 ```ruby
-DB.transaction do
+DB_1.transaction do
   id = users.insert name: 'User 1'
   users.update id, name: 'User updated'
   users.delete id
@@ -162,17 +190,53 @@ 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, :language, :categories, 'comments.user') # => [Post(User, Language, [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, ...]
+
+posts.each { |post| do_something post } # Iterate posts loading all at first
+posts.each(batch_size: 1000) { |post| do_something post } # Iterate posts loading in batches
+posts.each_batch(size: 1000) { |posts| do_something posts } # Iterate batches of posts
+```
+### 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.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
@@ -12,7 +14,6 @@ module Rasti
     extend MultiRequire
     extend ClassConfig
 
-    require_relative 'db/helpers'
     require_relative 'db/query'
     require_relative_pattern  'db/relations/*'
     require_relative_pattern  'db/type_converters/postgres_types/*'

data/lib/rasti/db/collection.rb

@@ -2,10 +2,7 @@ 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
-
-      include Enumerable
-      include Helpers::WithSchema
+      QUERY_METHODS = Query.public_instance_methods - Object.public_instance_methods
 
       class << self
 
@@ -16,8 +13,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 - computed_attributes.keys
         end
 
         def primary_key
@@ -38,12 +35,20 @@ module Rasti
           end
         end
 
+        def data_source_name
+          @data_source_name ||= superclass.respond_to?(:data_source_name) ? superclass.data_source_name : :default
+        end
+
         def relations
-          @relations ||= {}
+          @relations ||= Hash::Indifferent.new
         end
 
         def queries
-          @queries ||= {}
+          @queries ||= Hash::Indifferent.new
+        end
+
+        def computed_attributes
+          @computed_attributes ||= Hash::Indifferent.new
         end
 
         private
@@ -64,11 +69,17 @@ module Rasti
           @model = model
         end
 
+        def set_data_source_name(name)
+          @data_source_name = name.to_sym
+        end
+
         [Relations::OneToMany, Relations::ManyToOne, Relations::ManyToMany, Relations::OneToOne].each do |relation_class|
           define_method underscore(demodulize(relation_class.name)) do |name, options={}|
             relations[name] = relation_class.new name, self, options
 
-            query "with_#{pluralize(name)}".to_sym do |primary_keys|
+            query_name = relations[name].to_many? ? name : pluralize(name)
+
+            query "with_#{query_name}" do |primary_keys|
               with_related name, primary_keys
             end
           end
@@ -80,25 +91,29 @@ 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
 
-      end
+        def computed_attribute(name, &block)
+          raise "Computed Attribute #{name} already exists" if computed_attributes.key? name
+          computed_attributes[name] = block.call
+        end
 
-      attr_reader :db, :schema
+      end
 
-      def initialize(db, schema=nil)
-        @db = db
-        @schema = schema ? schema.to_sym : nil
+      def initialize(environment)
+        @environment = environment
       end
 
-      def dataset
-        db[qualified_collection_name]
+      QUERY_METHODS.each do |method|
+        define_method method do |*args, &block|
+          default_query.public_send method, *args, &block
+        end
       end
 
       def insert(attributes)
-        db.transaction do
+        data_source.db.transaction do
           db_attributes = transform_attributes_to_db attributes
           collection_attributes, relations_primary_keys = split_related_attributes db_attributes
           primary_key = dataset.insert collection_attributes
@@ -121,7 +136,7 @@ module Rasti
       end
 
       def update(primary_key, attributes)
-        db.transaction do
+        data_source.db.transaction do
           db_attributes = transform_attributes_to_db attributes
           collection_attributes, relations_primary_keys = split_related_attributes db_attributes
           dataset.where(self.class.primary_key => primary_key).update(collection_attributes) unless collection_attributes.empty?
@@ -147,7 +162,7 @@ module Rasti
       end
 
       def delete_relations(primary_key, relations)
-        db.transaction do
+        data_source.db.transaction do
           relations.each do |relation_name, relation_primary_keys|
             relation = self.class.relations[relation_name]
             delete_relation_table relation, primary_key, relation_primary_keys
@@ -157,7 +172,7 @@ module Rasti
       end
 
       def delete_cascade(*primary_keys)
-        db.transaction do
+        data_source.db.transaction do
           delete_cascade_relations primary_keys
           bulk_delete { |q| q.where self.class.primary_key => primary_keys }
         end
@@ -172,12 +187,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
@@ -188,27 +197,45 @@ module Rasti
 
       private
 
-      def transform_attributes_to_db(attributes)
-        attributes.each_with_object({}) do |(attribute_name, value), result| 
-          transformed_value = Rasti::DB.to_db db, qualified_collection_name, attribute_name, value
-          result[attribute_name] = transformed_value
-        end
+      attr_reader :environment
+
+      def data_source
+        @data_source ||= environment.data_source_of self.class
+      end
+
+      def dataset
+        data_source.db[qualified_collection_name]
       end
 
       def qualified_collection_name
-        schema.nil? ? Sequel[self.class.collection_name] : Sequel[schema][self.class.collection_name]
+        data_source.qualify self.class.collection_name
       end
       
-      def query
-        Query.new self.class, dataset, [], schema
+      def qualify(collection_name, data_source_name: nil)
+        data_source_name ||= self.class.data_source_name
+        environment.qualify data_source_name, collection_name
+      end
+
+      def default_query
+        Query.new collection_class: self.class, 
+                  dataset: dataset.select_all(self.class.collection_name), 
+                  environment: environment
       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
+
+      def transform_attributes_to_db(attributes)
+        attributes.each_with_object({}) do |(attribute_name, value), result| 
+          transformed_value = Rasti::DB.to_db data_source.db, qualified_collection_name, attribute_name, value
+          result[attribute_name] = transformed_value
         end
       end
 
@@ -237,18 +264,22 @@ module Rasti
         end
 
         relations.select { |r| r.one_to_many? || r.one_to_one? }.each do |relation|
-          relation_collection_name = with_schema(relation.target_collection_class.collection_name)
-          relations_ids = db[relation_collection_name].where(relation.foreign_key => primary_keys)
-                                                      .select(relation.target_collection_class.primary_key)
-                                                      .map(relation.target_collection_class.primary_key)
+          relation_data_source = environment.data_source_of relation.target_collection_class
+          relation_collection_name = relation_data_source.qualify relation.target_collection_class.collection_name
 
-          target_collection = relation.target_collection_class.new db, schema
+          relations_ids = relation_data_source.db[relation_collection_name]
+                                              .where(relation.foreign_key => primary_keys)
+                                              .select(relation.target_collection_class.primary_key)
+                                              .map(relation.target_collection_class.primary_key)
+
+          target_collection = relation.target_collection_class.new environment
           target_collection.delete_cascade(*relations_ids) unless relations_ids.empty?
         end
       end
 
       def insert_relation_table(relation, primary_key, relation_primary_keys)
-        relation_collection_name = relation.qualified_relation_collection_name(schema)
+        relation_data_source = environment.data_source relation.relation_data_source_name
+        relation_collection_name = relation_data_source.qualify relation.relation_collection_name
 
         values = relation_primary_keys.map do |relation_pk| 
           {
@@ -257,12 +288,14 @@ module Rasti
           }
         end
 
-        db[relation_collection_name].multi_insert values
+        relation_data_source.db[relation_collection_name].multi_insert values
       end
 
       def delete_relation_table(relation, primary_keys, relation_primary_keys=nil)
-        relation_collection_name = relation.qualified_relation_collection_name(schema)
-        ds = db[relation_collection_name].where(relation.source_foreign_key => primary_keys)
+        relation_data_source = environment.data_source relation.relation_data_source_name
+        relation_collection_name = relation_data_source.qualify relation.relation_collection_name
+
+        ds = relation_data_source.db[relation_collection_name].where(relation.source_foreign_key => primary_keys)
         ds = ds.where(relation.target_foreign_key => relation_primary_keys) if relation_primary_keys
         ds.delete
       end