rasti-db 2.2.0 → 3.0.0

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

@@ -47,39 +47,44 @@ module Rasti
         end
 
         rule comparison_include
-          attribute:attribute space* comparator:':' space* argument:basic <Nodes::Comparisons::Include>
+          attribute:attribute space* comparator:':' space* argument:argument <Nodes::Comparisons::Include>
         end
 
         rule comparison_not_include
-          attribute:attribute space* comparator:'!:' space* argument:basic <Nodes::Comparisons::NotInclude>
+          attribute:attribute space* comparator:'!:' space* argument:argument <Nodes::Comparisons::NotInclude>
         end
 
         rule comparison_like
-          attribute:attribute space* comparator:'~' space* argument:basic <Nodes::Comparisons::Like>
+          attribute:attribute space* comparator:'~' space* argument:argument <Nodes::Comparisons::Like>
         end
 
         rule comparison_greater_than
-          attribute:attribute 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
-          attribute:attribute space* comparator:'>=' space* argument:basic <Nodes::Comparisons::GreaterThanOrEqual>
+          attribute:attribute space* comparator:'>=' space* argument:argument <Nodes::Comparisons::GreaterThanOrEqual>
         end
 
         rule comparison_less_than
-          attribute:attribute 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
-          attribute:attribute space* comparator:'<=' space* argument:basic <Nodes::Comparisons::LessThanOrEqual>
+          attribute:attribute space* comparator:'<=' space* argument:argument <Nodes::Comparisons::LessThanOrEqual>
         end
 
         rule comparison_not_equal
-          attribute:attribute space* comparator:'!=' space* argument:basic <Nodes::Comparisons::NotEqual>
+          attribute:attribute space* comparator:'!=' space* argument:argument <Nodes::Comparisons::NotEqual>
         end
 
         rule comparison_equal
-          attribute:attribute 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,6 +96,14 @@ 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
@@ -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/relations/base.rb

@@ -2,7 +2,7 @@ module Rasti
   module DB
     module Relations
       class Base
-        
+
         include Sequel::Inflections
 
         attr_reader :name, :source_collection_class
@@ -63,10 +63,10 @@ module Rasti
 
         def validate_join!
           if source_collection_class.data_source_name != target_collection_class.data_source_name
-            raise "Invalid join of multiple data sources: #{source_collection_class.data_source_name}.#{source_collection_class.collection_name} > #{target_collection_class.data_source_name}.#{target_collection_class.collection_name}" 
+            raise "Invalid join of multiple data sources: #{source_collection_class.data_source_name}.#{source_collection_class.collection_name} > #{target_collection_class.data_source_name}.#{target_collection_class.collection_name}"
           end
         end
-        
+
       end
     end
   end

data/lib/rasti/db/relations/graph.rb

@@ -6,15 +6,15 @@ module Rasti
         def initialize(environment, collection_class, relations=[], selected_attributes={}, excluded_attributes={})
           @environment = environment
           @collection_class = collection_class
-          @graph = build_graph relations, 
-                               Hash::Indifferent.new(selected_attributes), 
+          @graph = build_graph relations,
+                               Hash::Indifferent.new(selected_attributes),
                                Hash::Indifferent.new(excluded_attributes)
         end
 
         def merge(relations:[], selected_attributes:{}, excluded_attributes:{})
-          Graph.new environment, 
-                    collection_class, 
-                    (flat_relations | relations), 
+          Graph.new environment,
+                    collection_class,
+                    (flat_relations | relations),
                     flat_selected_attributes.merge(selected_attributes),
                     flat_excluded_attributes.merge(excluded_attributes)
         end
@@ -22,7 +22,7 @@ module Rasti
         def with_all_attributes_for(relations)
           relations_with_all_attributes = relations.map { |r| [r, nil] }.to_h
 
-          merge selected_attributes: relations_with_all_attributes, 
+          merge selected_attributes: relations_with_all_attributes,
                 excluded_attributes: relations_with_all_attributes
         end
 
@@ -37,7 +37,7 @@ module Rasti
 
           graph.roots.each do |node|
             relation_of(node).fetch_graph environment,
-                                          rows, 
+                                          rows,
                                           node[:selected_attributes],
                                           node[:excluded_attributes] ,
                                           subgraph_of(node)
@@ -88,25 +88,25 @@ module Rasti
             excluded[id] = descendant[:excluded_attributes]
           end
 
-          Graph.new environment, 
-                    relation_of(node).target_collection_class, 
-                    relations, 
-                    selected, 
+          Graph.new environment,
+                    relation_of(node).target_collection_class,
+                    relations,
+                    selected,
                     excluded
         end
 
         def build_graph(relations, selected_attributes, excluded_attributes)
           HierarchicalGraph.new.tap do |graph|
-            flatten(relations).each do |relation| 
+            flatten(relations).each do |relation|
               sections = relation.split('.')
-              
+
               graph.add_node relation, name: sections.last.to_sym,
                                        selected_attributes: selected_attributes[relation],
                                        excluded_attributes: excluded_attributes[relation]
-              
+
               if sections.count > 1
                 parent_id = sections[0..-2].join('.')
-                graph.add_relation parent_id: parent_id, 
+                graph.add_relation parent_id: parent_id,
                                    child_id: relation
               end
             end

data/lib/rasti/db/relations/many_to_many.rb

@@ -54,19 +54,19 @@ module Rasti
 
           relations_graph.fetch_graph join_rows if relations_graph
 
-          relation_rows = join_rows.each_with_object(Hash.new { |h,k| h[k] = [] }) do |row, hash| 
-            attributes = row.select { |attr,_| target_collection_class.model.attributes.include? attr }
+          relation_rows = join_rows.each_with_object(Hash.new { |h,k| h[k] = [] }) do |row, hash|
+            attributes = row.select { |attr,_| target_collection_class.model.attribute_names.include? attr }
             hash[row[:source_foreign_key]] << target_collection_class.model.new(attributes)
           end
 
-          rows.each do |row| 
+          rows.each do |row|
             row[name] = relation_rows.fetch row[source_collection_class.primary_key], []
           end
         end
 
         def add_join(environment, dataset, prefix=nil)
           validate_join!
-          
+
           many_to_many_relation_alias = with_prefix prefix, "#{relation_collection_name}_#{SecureRandom.base64}"
 
           relation_name = prefix ? Sequel[prefix] : Sequel[source_collection_class.collection_name]

data/lib/rasti/db/relations/many_to_one.rb

@@ -17,18 +17,18 @@ module Rasti
           query = query.select_attributes(*selected_attributes) if selected_attributes
           query = relations_graph.apply_to query if relations_graph
 
-          relation_rows = query.each_with_object({}) do |row, hash| 
+          relation_rows = query.each_with_object({}) do |row, hash|
             hash[row.public_send(source_collection_class.primary_key)] = row
           end
-          
-          rows.each do |row| 
+
+          rows.each do |row|
             row[name] = relation_rows[row[foreign_key]]
           end
         end
 
         def add_join(environment, dataset, prefix=nil)
           validate_join!
-          
+
           relation_alias = join_relation_name prefix
 
           relation_name = prefix ? Sequel[prefix] : Sequel[source_collection_class.collection_name]

data/lib/rasti/db/relations/one_to_many.rb

@@ -19,14 +19,14 @@ module Rasti
 
           relation_rows = query.group_by(&foreign_key)
 
-          rows.each do |row| 
+          rows.each do |row|
             row[name] = build_graph_result relation_rows.fetch(row[source_collection_class.primary_key], [])
           end
         end
 
         def add_join(environment, dataset, prefix=nil)
           validate_join!
-          
+
           relation_alias = join_relation_name prefix
 
           relation_name = prefix ? Sequel[prefix] : Sequel[source_collection_class.collection_name]

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