rasti-db 1.5.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b801c94dd51c4ee11f624cb542d784a42e445622e0090c42cb9d47322b87e855
-  data.tar.gz: 518c58daf408e477f80cdac52837a0e2d3256938352c888a73e369f3eca5b7a2
+  metadata.gz: 210581882359ef05a1b09c69b172f259b0b5010b61a254442e9844158a4f9456
+  data.tar.gz: 1dd3f0fcc8399e0145abc50166495a87826bb1b32e52de4acb45ea114f7650d5
 SHA512:
-  metadata.gz: ae1452c9b77c6d50f9aa8b05b85f9970c801369e7e3a67a7a88436762fbacea4191390e114be066458d7bc2dc563f834cda93a364185354c74267db86798a889
-  data.tar.gz: 2707b44943ea63f17cd0f613c4fa08bdfc0663e8fde17f604c8c6ce9ba8f1fff23b4fa1641dfe42f77810a55fda6794491f5e8d8cb756c4fc19adb1cbb8cba76
+  metadata.gz: 2c209c735eb50327d4bb7b54754530cd155dec884e32661f046de73dfb53fb036877e1e25f1ade565ef51a0517254096d24934f3d6e47393febc99318ea71118
+  data.tar.gz: a5a8326418216e1558ffea4b93e52a2369420fed2c8d9633dda5ffd8ee34b457e06aaaea2018001ba8725e51c1ef44386a78e2abaa51819628eba93cec38da99

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
@@ -81,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
@@ -105,8 +119,8 @@ 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)
+      dataset.join(qualify(:comments), post_id: :id)
+             .where(Sequel[:comments][:user_id] => user_id)
              .select_all(:posts)
              .distinct
     end
@@ -129,19 +143,30 @@ class People < Rasti::DB::Collection
   set_model Person
 
   many_to_one :user
+  many_to_many :languages
 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 +199,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, ...]
 

data/lib/rasti/db.rb

@@ -14,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

@@ -4,8 +4,6 @@ module Rasti
 
       QUERY_METHODS = Query.public_instance_methods - Object.public_instance_methods
 
-      include Helpers::WithSchema
-
       class << self
 
         extend Sequel::Inflections
@@ -37,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
@@ -63,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
@@ -85,11 +93,8 @@ module Rasti
 
       end
 
-      attr_reader :db, :schema
-
-      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 +103,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 +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?
@@ -152,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
@@ -162,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
@@ -187,33 +188,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 +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
+
+          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 db, schema
+          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 +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

data/lib/rasti/db/data_source.rb

@@ -0,0 +1,18 @@
+module Rasti
+  module DB
+    class DataSource
+
+      attr_reader :db, :schema
+
+      def initialize(db, schema=nil)
+        @db = db
+        @schema = schema ? schema.to_sym : nil
+      end
+
+      def qualify(collection_name)
+        schema ? Sequel[schema][collection_name] : Sequel[collection_name]
+      end
+      
+    end
+  end
+end

data/lib/rasti/db/environment.rb

@@ -0,0 +1,32 @@
+module Rasti
+  module DB
+    class Environment
+
+      def initialize(data_sources)
+        @data_sources = data_sources
+      end
+
+      def data_source(name)
+        raise "Undefined data source #{name}" unless data_sources.key? name
+        data_sources[name]
+      end
+
+      def data_source_of(collection_class)
+        data_source collection_class.data_source_name
+      end
+
+      def qualify(data_source_name, collection_name)
+        data_source(data_source_name).qualify collection_name
+      end
+
+      def qualify_collection(collection_class)
+        data_source_of(collection_class).qualify collection_class.collection_name
+      end
+
+      private
+
+      attr_reader :data_sources
+
+    end
+  end
+end

data/lib/rasti/db/query.rb

@@ -5,13 +5,12 @@ module Rasti
       DATASET_CHAINED_METHODS = [:where, :exclude, :or, :order, :reverse_order, :limit, :offset].freeze
 
       include Enumerable
-      include Helpers::WithSchema
 
-      def initialize(collection_class:, dataset:, relations_graph:nil, schema:nil)
+      def initialize(environment:, collection_class:, dataset:, relations_graph:nil)
+        @environment = environment
         @collection_class = collection_class
         @dataset = dataset
-        @relations_graph = relations_graph || Relations::Graph.new(dataset.db, schema, collection_class)
-        @schema = schema
+        @relations_graph = relations_graph || Relations::Graph.new(environment, collection_class)
       end
 
       DATASET_CHAINED_METHODS.each do |method|
@@ -74,7 +73,7 @@ module Rasti
       end
 
       def join(*relations)
-        graph = Relations::Graph.new dataset.db, schema, collection_class, relations
+        graph = Relations::Graph.new environment, collection_class, relations
         
         ds = graph.add_joins(dataset)
                   .distinct
@@ -127,14 +126,14 @@ module Rasti
 
       private
 
-      attr_reader :collection_class, :dataset, :relations_graph, :schema
+      attr_reader :environment, :collection_class, :dataset, :relations_graph
 
       def build_query(**args)
         current_args = {
+          environment: environment,
           collection_class: collection_class,
           dataset: dataset,
-          relations_graph: relations_graph,
-          schema: schema
+          relations_graph: relations_graph
         }
 
         Query.new(**current_args.merge(args))
@@ -145,7 +144,7 @@ module Rasti
       end
 
       def with_related(relation_name, primary_keys)
-        ds = collection_class.relations[relation_name].apply_filter dataset, schema, primary_keys
+        ds = collection_class.relations[relation_name].apply_filter environment, dataset, primary_keys
         build_query dataset: ds
       end
 
@@ -155,6 +154,11 @@ module Rasti
         data
       end
 
+      def qualify(collection_name, data_source_name: nil)
+        data_source_name ||= collection_class.data_source_name
+        environment.qualify data_source_name, collection_name
+      end
+
       def nql_parser
         NQL::SyntaxParser.new
       end