rasti-db 1.5.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b801c94dd51c4ee11f624cb542d784a42e445622e0090c42cb9d47322b87e855
-  data.tar.gz: 518c58daf408e477f80cdac52837a0e2d3256938352c888a73e369f3eca5b7a2
+  metadata.gz: 057df50ee7debeb86b2ad63d4dffc965df8941e0f19ac4d4f96fe97ca319c314
+  data.tar.gz: c0cda671e2ea8f748b59c34108440edc7e016702f4d5832efac995a650005e62
 SHA512:
-  metadata.gz: ae1452c9b77c6d50f9aa8b05b85f9970c801369e7e3a67a7a88436762fbacea4191390e114be066458d7bc2dc563f834cda93a364185354c74267db86798a889
-  data.tar.gz: 2707b44943ea63f17cd0f613c4fa08bdfc0663e8fde17f604c8c6ce9ba8f1fff23b4fa1641dfe42f77810a55fda6794491f5e8d8cb756c4fc19adb1cbb8cba76
+  metadata.gz: d31034d885d8791bb04a2417372d56226c51b4fe8c54279d294148b22c68a7744f12887a948692f12e0b24c1a4abf8868b3c9250948ffb516e2c2515b42ea0aa
+  data.tar.gz: b75bc69a65eb10032f510ff5cb99cd511b69bc354c6bc3bc836e23612a0a21f9cc0a01849b752d58b1e86c0b9387adcb665ad609198495120a1da0c6fa2418a7

data/README.md

@@ -28,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
@@ -80,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
@@ -97,16 +111,16 @@ 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)
+      dataset.join(qualify(:comments), post_id: :id)
+             .where(Sequel[:comments][:user_id] => user_id)
              .select_all(:posts)
              .distinct
     end
@@ -129,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
 
-users      = Users.new DB
-posts      = Posts.new DB
-comments   = Comments.new DB
-categories = Categories.new DB
-people     = People.new DB
+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
+
+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
@@ -174,7 +203,7 @@ 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.graph(:user, :language, :categories, 'comments.user') # => [Post(User, Language, [Categories, ...], [Comments(User)]), ...]
 
 posts.join(:user).where(name: 'User 4') # => [Post, ...]
 
@@ -185,6 +214,10 @@ 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
 

data/lib/rasti/db.rb

@@ -6,21 +6,25 @@ require 'treetop'
 require 'hierarchical_graph'
 require 'class_config'
 require 'hash_ext'
+require 'inflecto'
 require 'multi_require'
 
 module Rasti
   module DB
-    
+
     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/*'
+    require_relative_pattern  'db/type_converters/sqlite_types/*'
+    require_relative 'db/nql/nodes/constants/base'
+    require_relative_pattern  'db/nql/filter_condition_strategies/types/*'
     require_relative_pattern  'db/**/*'
 
     attr_config :type_converters, []
+    attr_config :nql_filter_condition_strategy, nil
 
     def self.to_db(db, collection_name, attribute_name, value)
       type_converters.inject(value) do |result, type_converter|
@@ -34,5 +38,10 @@ module Rasti
       end
     end
 
+    def self.nql_filter_condition_for(comparison_name, identifier, argument)
+      raise 'Undefined Rasti::DB.nql_filter_condition_strategy' unless nql_filter_condition_strategy
+      nql_filter_condition_strategy.filter_condition_for comparison_name, identifier, argument
+    end
+
   end
 end

data/lib/rasti/db/collection.rb

@@ -4,8 +4,6 @@ module Rasti
 
       QUERY_METHODS = Query.public_instance_methods - Object.public_instance_methods
 
-      include Helpers::WithSchema
-
       class << self
 
         extend Sequel::Inflections
@@ -16,7 +14,7 @@ module Rasti
         end
 
         def collection_attributes
-          @collection_attributes ||= model.attributes - relations.keys
+          @collection_attributes ||= model.attributes - relations.keys - computed_attributes.keys
         end
 
         def primary_key
@@ -37,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
@@ -63,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
@@ -83,13 +95,15 @@ module Rasti
           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
 
       QUERY_METHODS.each do |method|
@@ -98,12 +112,8 @@ module Rasti
         end
       end
 
-      def dataset
-        db[qualified_collection_name]
-      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
@@ -126,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?
@@ -152,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
@@ -162,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
@@ -187,33 +197,48 @@ 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 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), 
-                  schema: schema
+                  environment: environment
       end
 
       def build_query(filter=nil, &block)
         raise ArgumentError, 'must specify filter hash or block' if filter.nil? && block.nil?
         
         if filter
-          default_query.where filter
+          default_query.where(filter)
         else
           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
+
       def split_related_attributes(attributes)
         relation_names = self.class.relations.values.select(&:many_to_many?).map(&:name)
 
@@ -239,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| 
           {
@@ -259,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

data/lib/rasti/db/computed_attribute.rb

@@ -0,0 +1,22 @@
+module Rasti
+  module DB
+    class ComputedAttribute
+
+      attr_reader :identifier
+
+      def initialize(identifier, &join)
+        @identifier = identifier
+        @join = join
+      end
+
+      def apply_join(dataset)
+        join ? join.call(dataset) : dataset
+      end
+
+      private
+
+      attr_reader :join
+
+    end
+  end
+end