rasti-db 2.1.0 → 2.3.3

data/lib/rasti/db/query.rb

@@ -57,14 +57,16 @@ module Rasti
         build_query relations_graph: relations_graph.with_all_attributes_for(relations)
       end
 
-      def append_computed_attribute(name)
-        computed_attribute = collection_class.computed_attributes[name]
-        ds = computed_attribute.apply_join(dataset).select_append(computed_attribute.identifier.as(name))
+      def select_computed_attributes(*computed_attributes)
+        ds = computed_attributes.inject(dataset) do |ds, name|
+          computed_attribute = collection_class.computed_attributes[name]
+          computed_attribute.apply_join(ds).select_append(computed_attribute.identifier.as(name))
+        end
         build_query dataset: ds
       end
 
       def all
-        with_graph(dataset.all).map do |row| 
+        with_graph(dataset.all).map do |row|
           collection_class.model.new row
         end
       end
@@ -74,13 +76,15 @@ module Rasti
         if batch_size.nil?
           all.each(&block)
         else
-          each_model_in_batches(size: batch_size, &block)
+          each_batch(size: batch_size) do |models|
+            models.each { |model| block.call model }
+          end
         end
       end
 
       def each_batch(size:, &block)
-        dataset.each_page(size) do |page|
-          query = build_query dataset: page
+        primary_keys.each_slice(size) do |pks|
+          query = where(collection_class.primary_key => pks)
           block.call query.all
         end
       end
@@ -167,14 +171,6 @@ module Rasti
         build_query dataset: instance_eval(&block)
       end
 
-      def each_model_in_batches(size:, &block)
-        dataset.each_page(size) do |page|
-          page.each do |row|
-            block.call build_model(row)
-          end
-        end
-      end
-
       def with_related(relation_name, primary_keys)
         ds = collection_class.relations[relation_name].apply_filter environment, dataset, primary_keys
         build_query dataset: ds

data/lib/rasti/db/type_converters/postgres.rb

@@ -3,62 +3,58 @@ module Rasti
     module TypeConverters
       class Postgres
 
-        CONVERTERS = [PostgresTypes::JSON, PostgresTypes::JSONB, PostgresTypes::HStore, PostgresTypes::Array]
-
-        @to_db_mapping = {}
+        CONVERTERS = [
+          PostgresTypes::JSON,
+          PostgresTypes::JSONB,
+          PostgresTypes::HStore,
+          PostgresTypes::Array
+        ]
 
         class << self
 
           def to_db(db, collection_name, attribute_name, value)
-            to_db_mapping = to_db_mapping_for db, collection_name
-
-            if to_db_mapping.key? attribute_name
-              to_db_mapping[attribute_name][:converter].to_db value, to_db_mapping[attribute_name][:sub_type]
-            else
-              value
-            end
+            converter, type = find_to_db_converter_and_type db, collection_name, attribute_name
+            converter ? converter.to_db(value, type) : value
           end
 
-          def from_db(object)
-            if from_db_mapping.key? object.class
-              from_db_mapping[object.class].from_db object
-            else
-              object
-            end
+          def from_db(value)
+            converter = find_from_db_converter value.class
+            converter ? converter.from_db(value) : value
           end
 
           private
 
-          def to_db_mapping_for(db, collection_name)
-            key = [db.opts[:database], collection_name]
-            
-            @to_db_mapping[key] ||= begin
-              columns = Hash[db.schema(collection_name)]
+          def from_db_converters
+            @from_db_converters ||= {}
+          end
 
-              columns.each_with_object({}) do |(name, schema), hash| 
-                CONVERTERS.each do |converter|
-                  unless hash.key? name
-                    match = converter.column_type_regex.match schema[:db_type]
+          def to_db_converters
+            @to_db_converters ||= {}
+          end
+
+          def find_to_db_converter_and_type(db, collection_name, attribute_name)
+            key = [db.opts[:database], collection_name]
 
-                    hash[name] = {converter: converter, sub_type: match.captures.first} if match
-                  end
-                end
+            to_db_converters[key] ||= begin
+              columns = Hash[db.schema(collection_name)]
+              to_db_converters[key] = columns.each_with_object({}) do |(name, schema), hash|
+                converter = CONVERTERS.detect { |c| c.to_db? schema[:db_type] }
+                hash[name] = [converter, schema[:db_type]] if converter
               end
             end
+
+            to_db_converters[key].fetch(attribute_name, [])
           end
 
-          def from_db_mapping
-            @from_db_mapping ||= begin
-              CONVERTERS.each_with_object({}) do |converter, result|
-                converter.db_classes.each do |db_class|
-                  result[db_class] = converter
-                end
-              end              
+          def find_from_db_converter(klass)
+            if !from_db_converters.key?(klass)
+              from_db_converters[klass] = CONVERTERS.detect { |c| c.from_db? klass }
             end
+
+            from_db_converters[klass]
           end
 
         end
-
       end
     end
   end

data/lib/rasti/db/type_converters/postgres_types/array.rb

@@ -3,28 +3,30 @@ module Rasti
     module TypeConverters
       module PostgresTypes
         class Array
-
           class << self
 
-            def column_type_regex
-              /^([a-z]+)\[\]$/
+            DB_TYPE_REGEX = /^([a-z]+)\[\]$/
+
+            def to_db?(type)
+              !type.match(DB_TYPE_REGEX).nil?
             end
 
-            def to_db(value, sub_type)
+            def to_db(value, type)
+              sub_type = type[0..-3]
               array = sub_type == 'hstore' ? value.map { |v| Sequel.hstore v } : value
               Sequel.pg_array array, sub_type
             end
 
-            def db_classes
-              [Sequel::Postgres::PGArray]
+            def from_db?(klass)
+              defined?(Sequel::Postgres::PGArray) &&
+              klass == Sequel::Postgres::PGArray
             end
 
-            def from_db(object)
-              object.to_a
+            def from_db(value)
+              value.to_a
             end
 
           end
-
         end
       end
     end

data/lib/rasti/db/type_converters/postgres_types/hstore.rb

@@ -3,27 +3,28 @@ module Rasti
     module TypeConverters
       module PostgresTypes
         class HStore
-
           class << self
 
-            def column_type_regex
-              /^hstore$/
+            DB_TYPE_REGEX = /^hstore$/
+
+            def to_db?(type)
+              !type.match(DB_TYPE_REGEX).nil?
             end
 
-            def to_db(value, sub_type)
+            def to_db(value, type)
               Sequel.hstore value
             end
 
-            def db_classes
-              [Sequel::Postgres::HStore]
+            def from_db?(klass)
+              defined?(Sequel::Postgres::HStore) &&
+              klass == Sequel::Postgres::HStore
             end
 
-            def from_db(object)
-              object.to_h
+            def from_db(value)
+              value.to_h
             end
 
           end
-
         end
       end
     end

data/lib/rasti/db/type_converters/postgres_types/json.rb

@@ -3,36 +3,39 @@ module Rasti
     module TypeConverters
       module PostgresTypes
         class JSON
-
           class << self
 
-            def column_type_regex
-              /^json$/
+            DB_TYPE_REGEX = /^json$/
+
+            def to_db?(type)
+              !type.match(DB_TYPE_REGEX).nil?
             end
 
-            def to_db(value, sub_type)
+            def to_db(value, type)
               Sequel.pg_json value
             end
 
-            def db_classes
-              @db_classes ||= from_db_convertions.keys
+            def from_db?(klass)
+              to_hash?(klass) || to_array?(klass)
             end
 
-            def from_db(object)
-              object.public_send from_db_convertions[object.class]
+            def from_db(value)
+              to_hash?(value.class) ? value.to_h : value.to_a
             end
 
             private
 
-            def from_db_convertions
-              @from_db_convertions ||= {
-                Sequel::Postgres::JSONHash => :to_h,
-                Sequel::Postgres::JSONArray => :to_a
-              }
+            def to_hash?(klass)
+              defined?(Sequel::Postgres::JSONHash) &&
+              klass == Sequel::Postgres::JSONHash
             end
 
-          end
+            def to_array?(klass)
+              defined?(Sequel::Postgres::JSONArray) &&
+              klass == Sequel::Postgres::JSONArray
+            end
 
+          end
         end
       end
     end

data/lib/rasti/db/type_converters/postgres_types/jsonb.rb

@@ -3,36 +3,39 @@ module Rasti
     module TypeConverters
       module PostgresTypes
         class JSONB
-
           class << self
 
-            def column_type_regex
-              /^jsonb$/
+            DB_TYPE_REGEX = /^jsonb$/
+
+            def to_db?(type)
+              !type.match(DB_TYPE_REGEX).nil?
             end
 
-            def to_db(value, sub_type)
+            def to_db(value, type)
               Sequel.pg_jsonb value
             end
 
-            def db_classes
-              @db_classes ||= from_db_convertions.keys
+            def from_db?(klass)
+              to_hash?(klass) || to_array?(klass)
             end
 
-            def from_db(object)
-              object.public_send from_db_convertions[object.class]
+            def from_db(value)
+              to_hash?(value.class) ? value.to_h : value.to_a
             end
 
             private
 
-            def from_db_convertions
-              @from_db_convertions ||= {
-                Sequel::Postgres::JSONBHash => :to_h,
-                Sequel::Postgres::JSONBArray => :to_a
-              }
+            def to_hash?(klass)
+              defined?(Sequel::Postgres::JSONBHash) &&
+              klass == Sequel::Postgres::JSONBHash
             end
 
-          end
+            def to_array?(klass)
+              defined?(Sequel::Postgres::JSONBArray) &&
+              klass == Sequel::Postgres::JSONBArray
+            end
 
+          end
         end
       end
     end

data/lib/rasti/db/type_converters/sqlite.rb

@@ -0,0 +1,62 @@
+module Rasti
+  module DB
+    module TypeConverters
+      class SQLite
+
+        CONVERTERS = [SQLiteTypes::Array]
+
+        @to_db_mapping = {}
+
+        class << self
+
+          def to_db(db, collection_name, attribute_name, value)
+            to_db_mapping = to_db_mapping_for db, collection_name
+
+            if to_db_mapping.key? attribute_name
+              to_db_mapping[attribute_name][:converter].to_db value
+            else
+              value
+            end
+          end
+
+          def from_db(object)
+            converter = find_converter_from_db object
+            if !converter.nil?
+              converter.from_db object
+            else
+              object
+            end
+          end
+
+          private
+
+          def to_db_mapping_for(db, collection_name)
+            key = [db.opts[:database], collection_name]
+
+            @to_db_mapping[key] ||= begin
+              columns = Hash[db.schema(collection_name)]
+
+              columns.each_with_object({}) do |(name, schema), hash|
+                CONVERTERS.each do |converter|
+                  unless hash.key? name
+                    match = converter.column_type_regex.match schema[:db_type]
+
+                    hash[name] = { converter: converter } if match
+                  end
+                end
+              end
+            end
+          end
+
+          def find_converter_from_db(object)
+            CONVERTERS.find do |converter|
+              converter.respond_for? object
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/type_converters/sqlite_types/array.rb

@@ -0,0 +1,34 @@
+module Rasti
+  module DB
+    module TypeConverters
+      module SQLiteTypes
+        class Array
+
+          class << self
+
+            def column_type_regex
+              /^([a-z]+)\[\]$/
+            end
+
+            def to_db(values)
+              JSON.dump(values)
+            end
+
+            def respond_for?(object)
+              parsed = JSON.parse object
+              object == to_db(parsed)
+            rescue
+              false
+            end
+
+            def from_db(object)
+              JSON.parse object
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/type_converters/time_in_zone.rb

@@ -6,7 +6,7 @@ module Rasti
         class << self
 
           def to_db(db, collection_name, attribute_name, value)
-            value
+            value.is_a?(Timing::TimeInZone) ? value.to_time : value
           end
 
           def from_db(value)