rasti-db 1.3.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aab2813290f3080c9a50cfed449183cc5da14e04915f6593fa9ab7fa5e5f24a7
-  data.tar.gz: 3d46e38905af30b1a50a8b186b5ebf3f3253db29b58eed2526859c12862cc8af
+  metadata.gz: 8b41f6198798c9bee6da1f94742378639bb3b900f3bda6471f791b42a71a24c7
+  data.tar.gz: f470e1f1ef5673546e54e6c144e16ebba577b0f848b8fd59c8822489808a7cbf
 SHA512:
-  metadata.gz: 5ae412446ff6d62b5cd1043e1958aaafe7dbc391ba98173adcc6ab5b31ce0d1daa8dc7086b62ae27ca50b7c03e6c2a1f6ac905a06a30a932a5e367e30698d8cd
-  data.tar.gz: 68e99deac8ffb297263a56a1e3f4deff341518f94aba48bbbb8a760983e86d9268a9a7d96a36626ca7fcf4173c512f23c3585bcbae047dc964de493b2a7256e4
+  metadata.gz: f5e836d580a42656efe1d78ee2e193449edd1adf45dbccd0a4b4c9c4d6f263a0d92e844a142abb908a683a8dcad4865d5926aec10b5a0260c0240425dcd063dd
+  data.tar.gz: 71148abafe56a6fe60613f2ebfa38138df2aaa656bdbe7116a834d41f3920fb49b97bfffac3235a520a6ffbb293184310d2d7fcefa552178d1cb767b94ce8e4d

data/.travis.yml

@@ -1,15 +1,14 @@
 language: ruby
 
 rvm:
-  - 2.0
   - 2.1
   - 2.2
-  - 2.3.0
-  - 2.4.0
-  - 2.5.0
-  - 2.6.0
-  - jruby-9.1.7.0
-  - jruby-9.1.16.0
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+  - jruby-9.2.9.0
   - ruby-head
   - jruby-head
 
@@ -20,8 +19,4 @@ matrix:
     - rvm: jruby-head
 
 jdk:
-  - openjdk8
-
-before_install:
-  - rvm all-gemsets do gem uninstall bundler -ax || true
-  - gem install bundler -v "< 2"
+  - openjdk8

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
@@ -82,6 +94,7 @@ Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :cat
 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]
+Language = Rasti::DB::Model[:id, :name, :people]
 ```
 
 ### Collections
@@ -106,9 +119,9 @@ class Posts < Rasti::DB::Collection
 
   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,30 @@ class People < Rasti::DB::Collection
   set_model Person
 
   many_to_one :user
+  many_to_many :languages
+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 +186,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, :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, ...]
+```
+### 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
         end
 
         def primary_key
@@ -38,12 +35,16 @@ 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
 
         private
@@ -64,11 +65,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 +87,24 @@ 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
 
-      attr_reader :db, :schema
-
-      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 +127,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 +153,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 +163,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 +178,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 +188,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 +255,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 +279,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