rasti-db 2.0.0 → 2.3.1

data/lib/rasti/db/nql/syntax.treetop

@@ -42,44 +42,49 @@ module Rasti
           comparison_equal
         end
 
-        rule field
-          _tables:(table:field_name '.')* _column:field_name <Nodes::Field>
+        rule attribute
+          _tables:(table:attribute_name '.')* _column:attribute_name <Nodes::Attribute>
         end
 
         rule comparison_include
-          field:field space* comparator:':' space* argument:basic <Nodes::Comparisons::Include>
+          attribute:attribute space* comparator:':' space* argument:argument <Nodes::Comparisons::Include>
         end
 
         rule comparison_not_include
-          field:field space* comparator:'!:' space* argument:basic <Nodes::Comparisons::NotInclude>
+          attribute:attribute space* comparator:'!:' space* argument:argument <Nodes::Comparisons::NotInclude>
         end
 
         rule comparison_like
-          field:field space* comparator:'~' space* argument:basic <Nodes::Comparisons::Like>
+          attribute:attribute space* comparator:'~' space* argument:argument <Nodes::Comparisons::Like>
         end
 
         rule comparison_greater_than
-          field:field space* comparator:'>' space* argument:basic <Nodes::Comparisons::GreaterThan>
+          attribute:attribute space* comparator:'>' space* argument:argument <Nodes::Comparisons::GreaterThan>
         end
 
         rule comparison_greater_than_or_equal
-          field:field space* comparator:'>=' space* argument:basic <Nodes::Comparisons::GreaterThanOrEqual>
+          attribute:attribute space* comparator:'>=' space* argument:argument <Nodes::Comparisons::GreaterThanOrEqual>
         end
 
         rule comparison_less_than
-          field:field space* comparator:'<' space* argument:basic <Nodes::Comparisons::LessThan>
+          attribute:attribute space* comparator:'<' space* argument:argument <Nodes::Comparisons::LessThan>
         end
 
         rule comparison_less_than_or_equal
-          field:field space* comparator:'<=' space* argument:basic <Nodes::Comparisons::LessThanOrEqual>
+          attribute:attribute space* comparator:'<=' space* argument:argument <Nodes::Comparisons::LessThanOrEqual>
         end
 
         rule comparison_not_equal
-          field:field space* comparator:'!=' space* argument:basic <Nodes::Comparisons::NotEqual>
+          attribute:attribute space* comparator:'!=' space* argument:argument <Nodes::Comparisons::NotEqual>
         end
 
         rule comparison_equal
-          field:field space* comparator:'=' space* argument:basic <Nodes::Comparisons::Equal>
+          attribute:attribute space* comparator:'=' space* argument:argument <Nodes::Comparisons::Equal>
+        end
+
+        rule argument
+          array /
+          basic
         end
 
         rule basic
@@ -91,11 +96,19 @@ module Rasti
           string
         end
 
+        rule array
+          open:'[' space* contents:(array_content / basic) space* close:']' <Nodes::Constants::Array>
+        end
+
+        rule array_content
+          left:basic space* ',' space* right:(array_content / basic) <Nodes::ArrayContent>
+        end
+
         rule space
           [\s\t\n]
         end
 
-        rule field_name
+        rule attribute_name
           [a-z_]+
         end
 
@@ -130,7 +143,7 @@ module Rasti
         end
 
         rule valid_character 
-          [0-9a-zA-ZÁÀÄÂÃÅĀĂǍáàäâãåāăǎÉÈËÊĒĔĖĚéèëêēĕėěÍÌÏÎĨĬǏíìïîĩĭǐÓÒÖÔÕŌŎŐǑóòöôõōŏőǒÚÙÜÛŨŪŬŮŰǓúùüûũūŭůűǔÑñçÇ%@#+-_'?!$*/\s]
+          [0-9a-zA-ZÁÀÄÂÃÅĀĂǍáàäâãåāăǎÉÈËÊĒĔĖĚéèëêēĕėěÍÌÏÎĨĬǏíìïîĩĭǐÓÒÖÔÕŌŎŐǑóòöôõōŏőǒÚÙÜÛŨŪŬŮŰǓúùüûũūŭůűǔÑñçÇ%@#+\--Z\\^_'?!$*/\s]
         end
 
         rule boolean
@@ -159,7 +172,7 @@ module Rasti
         end
 
         rule reserved_character
-          [&|.():!=<>~]
+          [&|.():!=<>~,\]\[]
         end
 
       end

data/lib/rasti/db/query.rb

@@ -9,7 +9,7 @@ module Rasti
       def initialize(environment:, collection_class:, dataset:, relations_graph:nil)
         @environment = environment
         @collection_class = collection_class
-        @dataset = dataset
+        @dataset = dataset.qualify collection_class.collection_name
         @relations_graph = relations_graph || Relations::Graph.new(environment, collection_class)
       end
 
@@ -57,15 +57,36 @@ module Rasti
         build_query relations_graph: relations_graph.with_all_attributes_for(relations)
       end
 
+      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
       alias_method :to_a, :all
 
-      def each(&block)
-        all.each(&block)
+      def each(batch_size:nil, &block)
+        if batch_size.nil?
+          all.each(&block)
+        else
+          each_batch(size: batch_size) do |models|
+            models.each { |model| block.call model }
+          end
+        end
+      end
+
+      def each_batch(size:, &block)
+        primary_keys.each_slice(size) do |pks|
+          query = where(collection_class.primary_key => pks)
+          block.call query.all
+        end
       end
 
       def graph(*relations)
@@ -74,11 +95,9 @@ module Rasti
 
       def join(*relations)
         graph = Relations::Graph.new environment, collection_class, relations
-        
-        ds = graph.add_joins(dataset)
-                  .distinct
-                  .select_all(collection_class.collection_name)
-        
+
+        ds = graph.add_joins(dataset).distinct
+
         build_query dataset: ds
       end
 
@@ -96,12 +115,12 @@ module Rasti
 
       def first
         row = dataset.first
-        row ? collection_class.model.new(with_graph(row)) : nil
+        row ? build_model(row) : nil
       end
 
       def last
         row = dataset.last
-        row ? collection_class.model.new(with_graph(row)) : nil
+        row ? build_model(row) : nil
       end
 
       def detect(*args, &block)
@@ -118,10 +137,15 @@ module Rasti
 
         raise NQL::InvalidExpressionError.new(filter_expression) if sentence.nil?
 
+        ds = sentence.computed_attributes(collection_class).inject(dataset) do |ds, name|
+          collection_class.computed_attributes[name].apply_join ds
+        end
+        query = build_query dataset: ds
+
         dependency_tables = sentence.dependency_tables
-        query = dependency_tables.empty? ? self : join(*dependency_tables)
-        
-        query.where sentence.filter_condition
+        query = query.join(*dependency_tables) unless dependency_tables.empty?
+
+        query.where sentence.filter_condition(collection_class)
       end
 
       private
@@ -139,6 +163,10 @@ module Rasti
         Query.new(**current_args.merge(args))
       end
 
+      def build_model(row)
+        collection_class.model.new with_graph(row)
+      end
+
       def chainable(&block)
         build_query dataset: instance_eval(&block)
       end

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].join('.')
 
-                    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