activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/active_node/query/query_proxy_eager_loading.rb

@@ -0,0 +1,177 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      module QueryProxyEagerLoading
+        class IdentityMap < Hash
+          def add(node)
+            self[node.neo_id] ||= node
+          end
+        end
+
+        def pluck_vars(node, rel)
+          with_associations_tree.empty? ? super : perform_query
+        end
+
+        def perform_query
+          @_cache = IdentityMap.new
+          build_query
+            .map do |record, eager_data|
+            cache_and_init(record, with_associations_tree)
+            eager_data.zip(with_associations_tree.paths.map(&:last)).each do |eager_records, element|
+              eager_records.first.zip(eager_records.last).each do |eager_record|
+                add_to_cache(*eager_record, element)
+              end
+            end
+            record
+          end
+        end
+
+        def with_associations(*spec)
+          new_link.tap do |new_query_proxy|
+            new_query_proxy.with_associations_tree = with_associations_tree.clone
+            new_query_proxy.with_associations_tree.add_spec(spec)
+          end
+        end
+
+        def propagate_context(query_proxy)
+          super
+          query_proxy.instance_variable_set('@with_associations_tree', @with_associations_tree)
+        end
+
+        def with_associations_tree
+          @with_associations_tree ||= association_tree_class.new(model)
+        end
+
+        def association_tree_class
+          AssociationTree
+        end
+
+        def with_associations_tree=(tree)
+          @with_associations_tree = tree
+        end
+
+        def first
+          (query.clause?(:order) ? self : order(order_property)).limit(1).to_a.first
+        end
+
+        private
+
+        def add_to_cache(rel, node, element)
+          direction = element.association.direction
+          node = cache_and_init(node, element)
+          if rel.is_a?(Neo4j::ActiveRel)
+            rel.instance_variable_set(direction == :in ? '@from_node' : '@to_node', node)
+          end
+          @_cache[direction == :out ? rel.start_node_neo_id : rel.end_node_neo_id]
+            .association_proxy(element.name).add_to_cache(node, rel)
+        end
+
+        def init_associations(node, element)
+          element.each_key { |key| node.association_proxy(key).init_cache }
+          node.association_proxy(element.name).init_cache if element.rel_length == ''
+        end
+
+        def cache_and_init(node, element)
+          @_cache.add(node).tap { |n| init_associations(n, element) }
+        end
+
+        def with_associations_return_clause
+          path_names.map { |n| var(n, :collection, &:itself) }.join(',')
+        end
+
+        def var(*parts)
+          yield(escape(parts.compact.join('_')))
+        end
+
+        # In neo4j version 2.1.8 this fails due to a bug:
+        # MATCH (`n`) WITH `n` RETURN `n`
+        # but this
+        # MATCH (`n`) WITH n RETURN `n`
+        # and this
+        # MATCH (`n`) WITH `n` AS `n` RETURN `n`
+        # does not
+        def var_fix(*var)
+          var(*var, &method(:as_alias))
+        end
+
+        def as_alias(var)
+          "#{var} AS #{var}"
+        end
+
+        def escape(s)
+          "`#{s}`"
+        end
+
+        def path_name(path)
+          path.map(&:name).join('.')
+        end
+
+        def path_names
+          with_associations_tree.paths.map { |path| path_name(path) }
+        end
+
+        def build_query
+          before_pluck(query_from_association_tree).pluck(identity, "[#{with_associations_return_clause}]")
+        end
+
+        def before_pluck(query)
+          query_from_chain(@order_chain, query, identity)
+        end
+
+        def query_from_association_tree
+          previous_with_vars = []
+          with_associations_tree.paths.inject(query_as(identity).with(ensure_distinct(identity))) do |query, path|
+            with_association_query_part(query, path, previous_with_vars).tap do
+              previous_with_vars << var_fix(path_name(path), :collection)
+            end
+          end
+        end
+
+        def with_association_query_part(base_query, path, previous_with_vars)
+          optional_match_with_where(base_query, path, previous_with_vars)
+            .with(identity,
+                  "[#{relationship_collection(path)}, collect(#{escape path_name(path)})] "\
+                  "AS #{escape("#{path_name(path)}_collection")}",
+                  *previous_with_vars)
+        end
+
+        def relationship_collection(path)
+          path.last.rel_length ? "collect(last(relationships(#{escape("#{path_name(path)}_path")})))" : "collect(#{escape("#{path_name(path)}_rel")})"
+        end
+
+        def optional_match_with_where(base_query, path, _)
+          path
+            .each_with_index.map { |_, index| path[0..index] }
+            .inject(optional_match(base_query, path)) do |query, path_prefix|
+            query.where(path_prefix.last.association.target_where_clause(escape(path_name(path_prefix))))
+          end
+        end
+
+        def optional_match(base_query, path)
+          start_path = "#{escape("#{path_name(path)}_path")}=(#{identity})"
+          base_query.optional_match(
+            "#{start_path}#{path.each_with_index.map do |element, index|
+              relationship_part(element.association, path_name(path[0..index]), element.rel_length)
+            end.join}"
+          )
+        end
+
+        def relationship_part(association, path_name, rel_length)
+          if rel_length
+            rel_name = nil
+            length = {max: rel_length}
+          else
+            rel_name = escape("#{path_name}_rel")
+            length = nil
+          end
+          "#{association.arrow_cypher(rel_name, {}, false, false, length)}(#{escape(path_name)})"
+        end
+
+        def chain
+          @order_chain = @chain.select { |link| link.clause == :order } unless with_associations_tree.empty?
+          @chain
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/query/query_proxy_eager_loading/association_tree.rb

@@ -0,0 +1,75 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      module QueryProxyEagerLoading
+        class AssociationTree < Hash
+          attr_accessor :model, :name, :association, :path, :rel_length
+
+          def initialize(model, name = nil, rel_length = nil)
+            super()
+            self.model = name ? target_class(model, name) : model
+            self.name = name
+            self.association = name ? model.associations[name] : nil
+            self.rel_length = rel_length
+          end
+
+          def clone
+            super.tap { |copy| copy.each { |key, value| copy[key] = value.clone } }
+          end
+
+          def add_spec(spec)
+            fail_spec(spec) unless model
+
+            case spec
+            when nil
+              nil
+            when Array
+              spec.each(&method(:add_spec))
+            when Hash
+              process_hash(spec)
+            when String
+              process_string(spec)
+            else
+              add_key(spec)
+            end
+          end
+
+          def fail_spec(spec)
+            fail "Cannot eager load \"past\" a polymorphic association. \
+              (Since the association can return multiple models, we don't how to handle the \"#{spec}\" association.)"
+          end
+
+          def paths(*prefix)
+            values.flat_map { |v| [[*prefix, v]] + v.paths(*prefix, v) }
+          end
+
+          def process_hash(spec)
+            spec.each { |key, value| add_nested(key, value) }
+          end
+
+          def add_key(key, length = nil)
+            self[key] ||= self.class.new(model, key, length)
+          end
+
+          def add_nested(key, value, length = nil)
+            add_key(key, length).add_spec(value)
+          end
+
+          def process_string(str)
+            head, rest = str.split('.', 2)
+            k, length = head.split('*', -2)
+            add_nested(k.to_sym, rest, length)
+          end
+
+          private
+
+          def target_class(model, key)
+            association = model.associations[key]
+            fail "Invalid association: #{[*path, key].join('.')}" unless association
+            model.associations[key].target_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/query/query_proxy_enumerable.rb

@@ -0,0 +1,110 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      # Methods related to returning nodes and rels from QueryProxy
+      module QueryProxyEnumerable
+        include Enumerable
+
+        # Just like every other <tt>each</tt> but it allows for optional params to support the versions that also return relationships.
+        # The <tt>node</tt> and <tt>rel</tt> params are typically used by those other methods but there's nothing stopping you from
+        # using `your_node.each(true, true)` instead of `your_node.each_with_rel`.
+        # @return [Enumerable] An enumerable containing some combination of nodes and rels.
+        def each(node = true, rel = nil, &block)
+          result(node, rel).each(&block)
+        end
+
+        def result(node = true, rel = nil)
+          return [].freeze if unpersisted_start_object?
+
+          @result_cache ||= {}
+          return result_cache_for(node, rel) if result_cache?(node, rel)
+
+          result = pluck_vars(node, rel)
+          set_instance_caches(result, node, rel)
+
+          @result_cache[[node, rel]] ||= result
+        end
+
+        def result_cache?(node = true, rel = nil)
+          !!result_cache_for(node, rel)
+        end
+
+        def result_cache_for(node = true, rel = nil)
+          (@result_cache || {})[[node, rel]]
+        end
+
+        def fetch_result_cache
+          @result_cache ||= yield
+        end
+
+        # When called at the end of a QueryProxy chain, it will return the resultant relationship objects intead of nodes.
+        # For example, to return the relationship between a given student and their lessons:
+        #
+        # .. code-block:: ruby
+        #
+        #   student.lessons.each_rel do |rel|
+        #
+        # @return [Enumerable] An enumerable containing any number of applicable relationship objects.
+        def each_rel(&block)
+          block_given? ? each(false, true, &block) : to_enum(:each, false, true)
+        end
+
+        # When called at the end of a QueryProxy chain, it will return the nodes and relationships of the last link.
+        # For example, to return a lesson and each relationship to a given student:
+        #
+        # .. code-block:: ruby
+        #
+        #   student.lessons.each_with_rel do |lesson, rel|
+        def each_with_rel(&block)
+          block_given? ? each(true, true, &block) : to_enum(:each, true, true)
+        end
+
+        # Does exactly what you would hope. Without it, comparing `bobby.lessons == sandy.lessons` would evaluate to false because it
+        # would be comparing the QueryProxy objects, not the lessons themselves.
+        def ==(other)
+          self.to_a == other
+        end
+
+        # For getting variables which have been defined as part of the association chain
+        def pluck(*args)
+          transformable_attributes = (model ? model.attribute_names : []) + %w(uuid neo_id)
+          arg_list = args.map do |arg|
+            arg = Neo4j::ActiveNode::Query::QueryProxy::Link.converted_key(model, arg)
+            if transformable_attributes.include?(arg.to_s)
+              {identity => arg}
+            else
+              arg
+            end
+          end
+
+          self.query.pluck(*arg_list)
+        end
+
+        protected
+
+        def ensure_distinct(node, force = false)
+          @distinct || force ? "DISTINCT(#{node})" : node
+        end
+
+        private
+
+        def pluck_vars(node, rel)
+          vars = []
+          vars << ensure_distinct(identity) if node
+          vars << @rel_var if rel
+          pluck(*vars)
+        end
+
+        def set_instance_caches(instance, node, rel)
+          instance.each do |object|
+            object.instance_variable_set('@source_query_proxy', self)
+            object.instance_variable_set('@source_proxy_result_cache', instance)
+            if node && rel && object.last.is_a?(Neo4j::ActiveRel)
+              object.last.instance_variable_set(association.direction == :in ? '@from_node' : '@to_node', object.first)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/query/query_proxy_find_in_batches.rb

@@ -0,0 +1,19 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      module QueryProxyFindInBatches
+        def find_in_batches(options = {})
+          query.return(identity).find_in_batches(identity, @model.primary_key, options) do |batch|
+            yield batch.map(&identity)
+          end
+        end
+
+        def find_each(options = {})
+          query.return(identity).find_each(identity, @model.primary_key, options) do |result|
+            yield result.send(identity)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/query/query_proxy_link.rb

@@ -0,0 +1,139 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      class QueryProxy
+        class Link
+          attr_reader :clause
+
+          def initialize(clause, arg, args = [])
+            @clause = clause
+            @arg = arg
+            @args = args
+          end
+
+          def args(var, rel_var)
+            if @arg.respond_to?(:call)
+              @arg.call(var, rel_var)
+            else
+              [@arg] + @args
+            end
+          end
+
+          class << self
+            def for_clause(clause, arg, model, *args)
+              method_to_call = "for_#{clause}_clause"
+
+              send(method_to_call, arg, model, *args)
+            end
+
+            def for_where_clause(arg, model, *args)
+              node_num = 1
+              result = []
+              if arg.is_a?(Hash)
+                arg.each do |key, value|
+                  if model && model.association?(key)
+                    result += for_association(key, value, "n#{node_num}", model)
+                    node_num += 1
+                  else
+                    result << new_for_key_and_value(model, key, value)
+                  end
+                end
+              elsif arg.is_a?(String)
+                result << new(:where, arg, args)
+              end
+              result
+            end
+            alias for_node_where_clause for_where_clause
+
+            def for_where_not_clause(*args)
+              for_where_clause(*args).each do |link|
+                link.instance_variable_set('@clause', :where_not)
+              end
+            end
+
+            def new_for_key_and_value(model, key, value)
+              key = converted_key(model, key)
+
+              val = if !model
+                      value
+                    elsif key == model.id_property_name && value.is_a?(Neo4j::ActiveNode)
+                      value.id
+                    else
+                      converted_value(model, key, value)
+                    end
+
+              new(:where, ->(v, _) { {v => {key => val}} })
+            end
+
+            def for_association(name, value, n_string, model)
+              neo_id = value.try(:neo_id) || value
+              fail ArgumentError, "Invalid value for '#{name}' condition" if not neo_id.is_a?(Integer)
+
+              [
+                new(:match, ->(v, _) { "(#{v})#{model.associations[name].arrow_cypher}(#{n_string})" }),
+                new(:where, ->(_, _) { {"ID(#{n_string})" => neo_id.to_i} })
+              ]
+            end
+
+            # We don't accept strings here. If you want to use a string, just use where.
+            def for_rel_where_clause(arg, _, association)
+              arg.each_with_object([]) do |(key, value), result|
+                rel_class = association.relationship_class if association.relationship_class
+                val =  rel_class ? converted_value(rel_class, key, value) : value
+                result << new(:where, ->(_, rel_var) { {rel_var => {key => val}} })
+              end
+            end
+
+            def for_rel_where_not_clause(*args)
+              for_rel_where_clause(*args).each do |link|
+                link.instance_variable_set('@clause', :where_not)
+              end
+            end
+
+            def for_rel_order_clause(arg, _)
+              [new(:order, ->(_, v) { arg.is_a?(String) ? arg : {v => arg} })]
+            end
+
+            def for_order_clause(arg, model)
+              [new(:order, ->(v, _) { arg.is_a?(String) ? arg : {v => converted_keys(model, arg)} })]
+            end
+
+            def for_args(model, clause, args, association = nil)
+              if [:where, :where_not].include?(clause) && args[0].is_a?(String) # Better way?
+                [for_arg(model, clause, args[0], *args[1..-1])]
+              elsif [:rel_where, :rel_where_not].include?(clause)
+                args.map { |arg| for_arg(model, clause, arg, association) }
+              else
+                args.map { |arg| for_arg(model, clause, arg) }
+              end
+            end
+
+            def for_arg(model, clause, arg, *args)
+              default = [Link.new(clause, arg, *args)]
+
+              Link.for_clause(clause, arg, model, *args) || default
+            rescue NoMethodError
+              default
+            end
+
+            def converted_keys(model, arg)
+              arg.is_a?(Hash) ? Hash[arg.map { |key, value| [converted_key(model, key), value] }] : arg
+            end
+
+            def converted_key(model, key)
+              if key.to_sym == :id
+                model ? model.id_property_name : :uuid
+              else
+                key
+              end
+            end
+
+            def converted_value(model, key, value)
+              model.declared_properties.value_for_where(key, value)
+            end
+          end
+        end
+      end
+    end
+  end
+end