rasti-db 1.4.0 → 2.2.0

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

@@ -42,44 +42,44 @@ 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:basic <Nodes::Comparisons::Include>
         end
 
         rule comparison_not_include
-          field:field space* comparator:'!:' space* argument:basic <Nodes::Comparisons::NotInclude>
+          attribute:attribute space* comparator:'!:' space* argument:basic <Nodes::Comparisons::NotInclude>
         end
 
         rule comparison_like
-          field:field space* comparator:'~' space* argument:basic <Nodes::Comparisons::Like>
+          attribute:attribute space* comparator:'~' space* argument:basic <Nodes::Comparisons::Like>
         end
 
         rule comparison_greater_than
-          field:field space* comparator:'>' space* argument:basic <Nodes::Comparisons::GreaterThan>
+          attribute:attribute space* comparator:'>' space* argument:basic <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:basic <Nodes::Comparisons::GreaterThanOrEqual>
         end
 
         rule comparison_less_than
-          field:field space* comparator:'<' space* argument:basic <Nodes::Comparisons::LessThan>
+          attribute:attribute space* comparator:'<' space* argument:basic <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:basic <Nodes::Comparisons::LessThanOrEqual>
         end
 
         rule comparison_not_equal
-          field:field space* comparator:'!=' space* argument:basic <Nodes::Comparisons::NotEqual>
+          attribute:attribute space* comparator:'!=' space* argument:basic <Nodes::Comparisons::NotEqual>
         end
 
         rule comparison_equal
-          field:field space* comparator:'=' space* argument:basic <Nodes::Comparisons::Equal>
+          attribute:attribute space* comparator:'=' space* argument:basic <Nodes::Comparisons::Equal>
         end
 
         rule basic
@@ -95,7 +95,7 @@ module Rasti
           [\s\t\n]
         end
 
-        rule field_name
+        rule attribute_name
           [a-z_]+
         end
 

data/lib/rasti/db/query.rb

@@ -5,13 +5,18 @@ 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=[], schema=nil)
+      def initialize(environment:, collection_class:, dataset:, relations_graph:nil)
+        @environment = environment
         @collection_class = collection_class
-        @dataset = dataset
-        @relations = relations
-        @schema = schema
+        @dataset = dataset.qualify collection_class.collection_name
+        @relations_graph = relations_graph || Relations::Graph.new(environment, collection_class)
+      end
+
+      DATASET_CHAINED_METHODS.each do |method|
+        define_method method do |*args, &block|
+          build_query dataset: dataset.public_send(method, *args, &block)
+        end
       end
 
       def raw
@@ -19,7 +24,7 @@ module Rasti
       end
 
       def pluck(*attributes)
-        ds = dataset.select(*attributes.map { |attr| Sequel[collection_class.collection_name][attr] })
+        ds = dataset.select(*attributes.map { |a| Sequel[collection_class.collection_name][a] })
         attributes.count == 1 ? ds.map { |r| r[attributes.first] } : ds.map(&:values)
       end
 
@@ -27,38 +32,73 @@ module Rasti
         pluck collection_class.primary_key
       end
 
+      def select_attributes(*attributes)
+        build_query dataset: dataset.select(*attributes.map { |a| Sequel[collection_class.collection_name][a] })
+      end
+
+      def exclude_attributes(*excluded_attributes)
+        attributes = collection_class.collection_attributes - excluded_attributes
+        select_attributes(*attributes)
+      end
+
+      def all_attributes
+        build_query dataset: dataset.select_all(collection_class.collection_name)
+      end
+
+      def select_graph_attributes(selected_attributes)
+        build_query relations_graph: relations_graph.merge(selected_attributes: selected_attributes)
+      end
+
+      def exclude_graph_attributes(excluded_attributes)
+        build_query relations_graph: relations_graph.merge(excluded_attributes: excluded_attributes)
+      end
+
+      def all_graph_attributes(*relations)
+        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
 
-      DATASET_CHAINED_METHODS.each do |method|
-        define_method method do |*args, &block|
-          Query.new collection_class, 
-                    dataset.public_send(method, *args, &block), 
-                    relations, 
-                    schema
+      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(*rels)
-        Query.new collection_class, 
-                  dataset, 
-                  (relations | rels), 
-                  schema
+      def graph(*relations)
+        build_query relations_graph: relations_graph.merge(relations: relations)
       end
 
-      def join(*rels)
-        Query.new collection_class, 
-                  Relations::GraphBuilder.joins_to(dataset, rels, collection_class, schema), 
-                  relations, 
-                  schema
+      def join(*relations)
+        graph = Relations::Graph.new environment, collection_class, relations
+
+        ds = graph.add_joins(dataset).distinct
+
+        build_query dataset: ds
       end
 
       def count
@@ -75,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)
@@ -97,33 +137,63 @@ 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
 
+      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
+        }
+
+        Query.new(**current_args.merge(args))
+      end
+
+      def build_model(row)
+        collection_class.model.new with_graph(row)
+      end
+
       def chainable(&block)
-        ds = instance_eval(&block)
-        Query.new collection_class, ds, relations, schema
+        build_query dataset: instance_eval(&block)
       end
 
       def with_related(relation_name, primary_keys)
-        ds = collection_class.relations[relation_name].apply_filter dataset, schema, primary_keys
-        Query.new collection_class, ds, relations, schema
+        ds = collection_class.relations[relation_name].apply_filter environment, dataset, primary_keys
+        build_query dataset: ds
       end
 
       def with_graph(data)
         rows = data.is_a?(Array) ? data : [data]
-        Relations::GraphBuilder.graph_to rows, relations, collection_class, dataset.db, schema
+        relations_graph.fetch_graph rows
         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
+
       def method_missing(method, *args, &block)
-        if collection_class.queries.key?(method)
-          instance_exec(*args, &collection_class.queries[method])
+        if collection_class.queries.key? method
+          instance_exec(*args, &collection_class.queries.fetch(method))
         else
           super
         end
@@ -133,12 +203,6 @@ module Rasti
         collection_class.queries.key?(method) || super
       end
 
-      def nql_parser
-        NQL::SyntaxParser.new
-      end
-
-      attr_reader :collection_class, :dataset, :relations, :schema
-
     end
   end
 end

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

@@ -33,25 +33,39 @@ module Rasti
           self.class == OneToOne
         end
 
-        def join_relation_name(prefix)
-          with_prefix prefix, name
+        def from_one?
+          one_to_one? || one_to_many?
         end
 
-        private
+        def from_many?
+          many_to_one? || many_to_many?
+        end
 
-        attr_reader :options
+        def to_one?
+          one_to_one? || many_to_one?
+        end
 
-        def qualified_source_collection_name(schema=nil)
-          schema.nil? ? Sequel[source_collection_class.collection_name] : Sequel[schema][source_collection_class.collection_name]
+        def to_many?
+          one_to_many? || many_to_many?
         end
 
-        def qualified_target_collection_name(schema=nil)
-          schema.nil? ? Sequel[target_collection_class.collection_name] : Sequel[schema][target_collection_class.collection_name]
+        def join_relation_name(prefix)
+          with_prefix prefix, name
         end
 
+        private
+
+        attr_reader :options
+
         def with_prefix(prefix, name)
           [prefix, name].compact.join('__').to_sym
         end
+
+        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}" 
+          end
+        end
         
       end
     end

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

@@ -0,0 +1,129 @@
+module Rasti
+  module DB
+    module Relations
+      class Graph
+
+        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), 
+                               Hash::Indifferent.new(excluded_attributes)
+        end
+
+        def merge(relations:[], selected_attributes:{}, excluded_attributes:{})
+          Graph.new environment, 
+                    collection_class, 
+                    (flat_relations | relations), 
+                    flat_selected_attributes.merge(selected_attributes),
+                    flat_excluded_attributes.merge(excluded_attributes)
+        end
+
+        def with_all_attributes_for(relations)
+          relations_with_all_attributes = relations.map { |r| [r, nil] }.to_h
+
+          merge selected_attributes: relations_with_all_attributes, 
+                excluded_attributes: relations_with_all_attributes
+        end
+
+        def apply_to(query)
+          query.graph(*flat_relations)
+               .select_graph_attributes(flat_selected_attributes)
+               .exclude_graph_attributes(flat_excluded_attributes)
+        end
+
+        def fetch_graph(rows)
+          return if rows.empty?
+
+          graph.roots.each do |node|
+            relation_of(node).fetch_graph environment,
+                                          rows, 
+                                          node[:selected_attributes],
+                                          node[:excluded_attributes] ,
+                                          subgraph_of(node)
+          end
+        end
+
+        def add_joins(dataset, prefix=nil)
+          graph.roots.inject(dataset) do |ds, node|
+            relation = relation_of node
+            dataset_with_relation = relation.add_join environment, ds, prefix
+            subgraph_of(node).add_joins dataset_with_relation, relation.join_relation_name(prefix)
+          end
+        end
+
+        private
+
+        attr_reader :environment, :collection_class, :graph
+
+        def relation_of(node)
+          collection_class.relations.fetch(node[:name])
+        end
+
+        def flat_relations
+          graph.map(&:id)
+        end
+
+        def flat_selected_attributes
+          graph.each_with_object(Hash::Indifferent.new) do |node, hash|
+            hash[node.id] = node[:selected_attributes]
+          end
+        end
+
+        def flat_excluded_attributes
+          graph.each_with_object(Hash::Indifferent.new) do |node, hash|
+            hash[node.id] = node[:excluded_attributes]
+          end
+        end
+
+        def subgraph_of(node)
+          relations = []
+          selected = Hash::Indifferent.new
+          excluded = Hash::Indifferent.new
+
+          node.descendants.each do |descendant|
+            id = descendant.id[node[:name].length+1..-1]
+            relations << id
+            selected[id] = descendant[:selected_attributes]
+            excluded[id] = descendant[:excluded_attributes]
+          end
+
+          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| 
+              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, 
+                                   child_id: relation
+              end
+            end
+          end
+        end
+
+        def flatten(relations)
+          relations.flat_map do |relation|
+            parents = []
+            relation.to_s.split('.').map do |section|
+              parents << section
+              parents.compact.join('.')
+            end
+          end.uniq.sort
+        end
+
+      end
+    end
+  end
+end