neo4j_legacy 7.2.0.1

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

@@ -0,0 +1,90 @@
+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)
+          @result_cache ||= {}
+          return result_cache_for(node, rel) if result_cache?(node, rel)
+
+          pluck_vars = []
+          pluck_vars << identity if node
+          pluck_vars << @rel_var if rel
+
+          result = pluck(*pluck_vars)
+
+          result.each do |object|
+            object.instance_variable_set('@source_query_proxy', self)
+            object.instance_variable_set('@source_proxy_result_cache', result)
+          end
+
+          @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|
+            if transformable_attributes.include?(arg.to_s)
+              {identity => arg}
+            else
+              arg
+            end
+          end
+
+          self.query.pluck(*arg_list)
+        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,117 @@
+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)
+            @arg.respond_to?(:call) ? @arg.call(var, rel_var) : [@arg, @args].flatten
+          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_method :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 = (key.to_sym == :id ? model.id_property_name : 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_order_clause(arg, _)
+              [new(:order, ->(_, v) { arg.is_a?(String) ? arg : {v => arg} })]
+            end
+
+            def for_order_clause(arg, _)
+              [new(:order, ->(v, _) { arg.is_a?(String) ? arg : {v => 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 clause == :rel_where
+                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_value(model, key, value)
+              model.declared_properties.value_for_where(key, value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,210 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      module QueryProxyMethods
+        FIRST = 'HEAD'
+        LAST = 'LAST'
+
+        def rels
+          fail 'Cannot get rels without a relationship variable.' if !@rel_var
+
+          pluck(@rel_var)
+        end
+
+        def rel
+          rels.first
+        end
+
+        # Give ability to call `#find` on associations to get a scoped find
+        # Doesn't pass through via `method_missing` because Enumerable has a `#find` method
+        def find(*args)
+          scoping { @model.find(*args) }
+        end
+
+        def first(target = nil)
+          first_and_last(FIRST, target)
+        end
+
+        def last(target = nil)
+          first_and_last(LAST, target)
+        end
+
+        def order_property
+          # This should maybe be based on a setting in the association
+          # rather than a hardcoded `nil`
+          model ? model.id_property_name : nil
+        end
+
+        # @return [Integer] number of nodes of this class
+        def count(distinct = nil, target = nil)
+          fail(Neo4j::InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
+          query_with_target(target) do |var|
+            q = distinct.nil? ? var : "DISTINCT #{var}"
+            limited_query = self.query.clause?(:limit) ? self.query.break.with(var) : self.query.reorder
+            limited_query.pluck("count(#{q}) AS #{var}").first
+          end
+        end
+
+        def size
+          result_cache? ? result_cache_for.length : count
+        end
+
+        delegate :length, to: :to_a
+
+        # TODO: update this with public API methods if/when they are exposed
+        def limit_value
+          return unless self.query.clause?(:limit)
+          limit_clause = self.query.send(:clauses).find { |clause| clause.is_a?(Neo4j::Core::QueryClauses::LimitClause) }
+          limit_clause.instance_variable_get(:@arg)
+        end
+
+        def empty?(target = nil)
+          query_with_target(target) { |var| !self.exists?(nil, var) }
+        end
+
+        alias_method :blank?, :empty?
+
+        # @param [Neo4j::ActiveNode, Neo4j::Node, String] other An instance of a Neo4j.rb model, a Neo4j-core node, or a string uuid
+        # @param [String, Symbol] target An identifier of a link in the Cypher chain
+        # @return [Boolean]
+        def include?(other, target = nil)
+          query_with_target(target) do |var|
+            where_filter = if other.respond_to?(:neo_id)
+                             "ID(#{var}) = {other_node_id}"
+                           else
+                             "#{var}.#{association_id_key} = {other_node_id}"
+                           end
+            node_id = other.respond_to?(:neo_id) ? other.neo_id : other
+            self.where(where_filter).params(other_node_id: node_id).query.reorder.return("count(#{var}) as count").first.count > 0
+          end
+        end
+
+        def exists?(node_condition = nil, target = nil)
+          unless node_condition.is_a?(Integer) || node_condition.is_a?(Hash) || node_condition.nil?
+            fail(Neo4j::InvalidParameterError, ':exists? only accepts neo_ids')
+          end
+          query_with_target(target) do |var|
+            start_q = exists_query_start(node_condition, var)
+            start_q.query.reorder.return("COUNT(#{var}) AS count").first.count > 0
+          end
+        end
+
+        # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id}`
+        # The `node` param can be a persisted ActiveNode instance, any string or integer, or nil.
+        # When it's a node, it'll use the object's neo_id, which is fastest. When not nil, it'll figure out the
+        # primary key of that model. When nil, it uses `1 = 2` to prevent matching all records, which is the default
+        # behavior when nil is passed to `where` in QueryProxy.
+        # @param [#neo_id, String, Enumerable] node A node, a string representing a node's ID, or an enumerable of nodes or IDs.
+        # @return [Neo4j::ActiveNode::Query::QueryProxy] A QueryProxy object upon which you can build.
+        def match_to(node)
+          first_node = node.is_a?(Array) ? node.first : node
+          where_arg = if first_node.respond_to?(:neo_id)
+                        {neo_id: node.is_a?(Array) ? node.map(&:neo_id) : node}
+                      elsif !node.nil?
+                        {association_id_key => node.is_a?(Array) ? ids_array(node) : node}
+                      else
+                        # support for null object pattern
+                        '1 = 2'
+                      end
+
+          self.where(where_arg)
+        end
+
+
+        # Gives you the first relationship between the last link of a QueryProxy chain and a given node
+        # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id} RETURN r`
+        # @param [#neo_id, String, Enumerable] node An object to be sent to `match_to`. See params for that method.
+        # @return A relationship (ActiveRel, CypherRelationship, EmbeddedRelationship) or nil.
+        def first_rel_to(node)
+          self.match_to(node).limit(1).pluck(rel_var).first
+        end
+
+        # Returns all relationships across a QueryProxy chain between a given node or array of nodes and the preceeding link.
+        # @param [#neo_id, String, Enumerable] node An object to be sent to `match_to`. See params for that method.
+        # @return An enumerable of relationship objects.
+        def rels_to(node)
+          self.match_to(node).pluck(rel_var)
+        end
+        alias_method :all_rels_to, :rels_to
+
+        # When called, this method returns a single node that satisfies the match specified in the params hash.
+        # If no existing node is found to satisfy the match, one is created or associated as expected.
+        def find_or_create_by(params)
+          fail 'Method invalid when called on Class objects' unless source_object
+          result = self.where(params).first
+          return result unless result.nil?
+          Neo4j::Transaction.run do
+            node = model.find_or_create_by(params)
+            self << node
+            return node
+          end
+        end
+
+        # A shortcut for attaching a new, optional match to the end of a QueryProxy chain.
+        def optional(association, node_var = nil, rel_var = nil)
+          self.send(association, node_var, rel_var, optional: true)
+        end
+
+        # Takes an Array of ActiveNode models and applies the appropriate WHERE clause
+        # So for a `Teacher` model inheriting from a `Person` model and an `Article` model
+        # if you called .as_models([Teacher, Article])
+        # The where clause would look something like:
+        #
+        # .. code-block:: cypher
+        #
+        #   WHERE (node_var:Teacher:Person OR node_var:Article)
+        def as_models(models)
+          where_clause = models.map do |model|
+            "`#{identity}`:" + model.mapped_label_names.map do |mapped_label_name|
+              "`#{mapped_label_name}`"
+            end.join(':')
+          end.join(' OR ')
+
+          where("(#{where_clause})")
+        end
+
+        private
+
+        def first_and_last(func, target)
+          new_query, pluck_proc = if self.query.clause?(:order)
+                                    [self.query.with(identity),
+                                     proc { |var| "#{func}(COLLECT(#{var})) as #{var}" }]
+                                  else
+                                    [self.order(order_property).limit(1),
+                                     proc { |var| var }]
+                                  end
+          query_with_target(target) do |var|
+            final_pluck = pluck_proc.call(var)
+            new_query.pluck(final_pluck)
+          end.first
+        end
+
+        # @return [String] The primary key of a the current QueryProxy's model or target class
+        def association_id_key
+          self.association.nil? ? model.primary_key : self.association.target_class.primary_key
+        end
+
+        # @param [Enumerable] node An enumerable of nodes or ids.
+        # @return [Array] An array after having `id` called on each object
+        def ids_array(node)
+          node.first.respond_to?(:id) ? node.map(&:id) : node
+        end
+
+        def query_with_target(target)
+          yield(target || identity)
+        end
+
+        def exists_query_start(condition, target)
+          case condition
+          when Integer
+            self.where("ID(#{target}) = {exists_condition}").params(exists_condition: condition)
+          when Hash
+            self.where(condition.keys.first => condition.values.first)
+          else
+            self
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      module QueryProxyMethodsOfMassUpdating
+        # Updates some attributes of a group of nodes within a QP chain.
+        # The optional argument makes sense only of `updates` is a string.
+        # @param [Hash,String] updates An hash or a string of parameters to be updated.
+        # @param [Hash] params An hash of parameters for the update string. It's ignored if `updates` is an Hash.
+        def update_all(updates, params = {})
+          # Move this to ActiveNode module?
+          update_all_with_query(identity, updates, params)
+        end
+
+        # Updates some attributes of a group of relationships within a QP chain.
+        # The optional argument makes sense only of `updates` is a string.
+        # @param [Hash,String] updates An hash or a string of parameters to be updated.
+        # @param [Hash] params An hash of parameters for the update string. It's ignored if `updates` is an Hash.
+        def update_all_rels(updates, params = {})
+          fail 'Cannot update rels without a relationship variable.' unless @rel_var
+          update_all_with_query(@rel_var, updates, params)
+        end
+
+        # Deletes a group of nodes and relationships within a QP chain. When identifier is omitted, it will remove the last link in the chain.
+        # The optional argument must be a node identifier. A relationship identifier will result in a Cypher Error
+        # @param identifier [String,Symbol] the optional identifier of the link in the chain to delete.
+        def delete_all(identifier = nil)
+          query_with_target(identifier) do |target|
+            begin
+              self.query.with(target).optional_match("(#{target})-[#{target}_rel]-()").delete("#{target}, #{target}_rel").exec
+            rescue Neo4j::Session::CypherError
+              self.query.delete(target).exec
+            end
+            clear_source_object_cache
+          end
+        end
+
+        # Deletes the relationship between a node and its last link in the QueryProxy chain. Executed in the database, callbacks will not run.
+        def delete(node)
+          self.match_to(node).query.delete(rel_var).exec
+          clear_source_object_cache
+        end
+
+        # Deletes the relationships between all nodes for the last step in the QueryProxy chain.  Executed in the database, callbacks will not be run.
+        def delete_all_rels
+          return unless start_object && start_object._persisted_obj
+          self.query.delete(rel_var).exec
+        end
+
+        # Deletes the relationships between all nodes for the last step in the QueryProxy chain and replaces them with relationships to the given nodes.
+        # Executed in the database, callbacks will not be run.
+        def replace_with(node_or_nodes)
+          nodes = Array(node_or_nodes)
+
+          self.delete_all_rels
+          nodes.each { |node| self << node }
+        end
+
+        # Returns all relationships between a node and its last link in the QueryProxy chain, destroys them in Ruby. Callbacks will be run.
+        def destroy(node)
+          self.rels_to(node).map!(&:destroy)
+          clear_source_object_cache
+        end
+
+        private
+
+        def update_all_with_query(var_name, updates, params)
+          query = all.query
+
+          case updates
+          when Hash then query.set(var_name => updates).pluck("count(#{var_name})").first
+          when String then query.set(updates).params(params).pluck("count(#{var_name})").first
+          else
+            fail ArgumentError, "Invalid parameter type #{updates.class} for `updates`."
+          end
+        end
+
+        def clear_source_object_cache
+          self.source_object.clear_association_cache if self.source_object.respond_to?(:clear_association_cache)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/query.rb

@@ -0,0 +1,76 @@
+module Neo4j
+  module ActiveNode
+    # Helper methods to return Neo4j::Core::Query objects.  A query object can be used to successively build a cypher query
+    #
+    #    person.query_as(:n).match('n-[:friend]-o').return(o: :name) # Return the names of all the person's friends
+    #
+    module Query
+      extend ActiveSupport::Concern
+
+      # Returns a Query object with the current node matched the specified variable name
+      #
+      # @example Return the names of all of Mike's friends
+      #   # Generates: MATCH (mike:Person), mike-[:friend]-friend WHERE ID(mike) = 123 RETURN friend.name
+      #   mike.query_as(:mike).match('mike-[:friend]-friend').return(friend: :name)
+      #
+      # @param node_var [Symbol, String] The variable name to specify in the query
+      # @return [Neo4j::Core::Query]
+      def query_as(node_var)
+        self.class.query_as(node_var, false).where("ID(#{node_var})" => self.neo_id)
+      end
+
+      # Starts a new QueryProxy with the starting identifier set to the given argument and QueryProxy source_object set to the node instance.
+      # This method does not exist within QueryProxy and can only be used to start a new chain.
+      #
+      # @example Start a new QueryProxy chain with the first identifier set manually
+      #   # Generates: MATCH (s:`Student`), (l:`Lesson`), s-[rel1:`ENROLLED_IN`]->(l:`Lesson`) WHERE ID(s) = {neo_id_17963}
+      #   student.as(:s).lessons(:l)
+      #
+      # @param [String, Symbol] node_var The identifier to use within the QueryProxy object
+      # @return [Neo4j::ActiveNode::Query::QueryProxy]
+      def as(node_var)
+        self.class.query_proxy(node: node_var, source_object: self).match_to(self)
+      end
+
+      module ClassMethods
+        # Returns a Query object with all nodes for the model matched as the specified variable name
+        #
+        # @example Return the registration number of all cars owned by a person over the age of 30
+        #   # Generates: MATCH (person:Person), person-[:owned]-car WHERE person.age > 30 RETURN car.registration_number
+        #   Person.query_as(:person).where('person.age > 30').match('person-[:owned]-car').return(car: :registration_number)
+        #
+        # @param [Symbol, String] var The variable name to specify in the query
+        # @param [Boolean] with_labels Should labels be used to build the match? There are situations (neo_id used to filter,
+        # an early Cypher match has already filtered results) where including labels will degrade performance.
+        # @return [Neo4j::Core::Query]
+        def query_as(var, with_labels = true)
+          query_proxy.query_as(var, with_labels)
+        end
+
+        Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
+          define_method(method) do |*args|
+            self.query_proxy.send(method, *args)
+          end
+        end
+
+        def query_proxy(options = {})
+          Neo4j::ActiveNode::Query::QueryProxy.new(self, nil, options)
+        end
+
+        # Start a new QueryProxy with the starting identifier set to the given argument.
+        # This method does not exist within QueryProxy, it can only be called at the class level to create a new QP object.
+        # To set an identifier within a QueryProxy chain, give it as the first argument to a chained association.
+        #
+        # @example Start a new QueryProxy where the first identifier is set manually.
+        #   # Generates: MATCH (s:`Student`), (result_lessons:`Lesson`), s-[rel1:`ENROLLED_IN`]->(result_lessons:`Lesson`)
+        #   Student.as(:s).lessons
+        #
+        # @param [String, Symbol] node_var A string or symbol to use as the starting identifier.
+        # @return [Neo4j::ActiveNode::Query::QueryProxy]
+        def as(node_var)
+          query_proxy(node: node_var, context: self.name)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/query_methods.rb

@@ -0,0 +1,65 @@
+module Neo4j
+  module ActiveNode
+    module QueryMethods
+      def exists?(node_condition = nil)
+        unless node_condition.is_a?(Integer) || node_condition.is_a?(Hash) || node_condition.nil?
+          fail(Neo4j::InvalidParameterError, ':exists? only accepts ids or conditions')
+        end
+        query_start = exists_query_start(node_condition)
+        start_q = query_start.respond_to?(:query_as) ? query_start.query_as(:n) : query_start
+        start_q.return('COUNT(n) AS count').first.count > 0
+      end
+
+      # Returns the first node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
+      def first
+        self.query_as(:n).limit(1).order(n: primary_key).pluck(:n).first
+      end
+
+      # Returns the last node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
+      def last
+        self.query_as(:n).limit(1).order(n: {primary_key => :desc}).pluck(:n).first
+      end
+
+      # @return [Integer] number of nodes of this class
+      def count(distinct = nil)
+        fail(Neo4j::InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
+        q = distinct.nil? ? 'n' : 'DISTINCT n'
+        self.query_as(:n).return("count(#{q}) AS count").first.count
+      end
+
+      alias_method :size, :count
+      alias_method :length, :count
+
+      def empty?
+        !self.all.exists?
+      end
+
+      alias_method :blank?, :empty?
+
+      def find_in_batches(options = {})
+        self.query_as(:n).return(:n).find_in_batches(:n, primary_key, options) do |batch|
+          yield batch.map(&:n)
+        end
+      end
+
+      def find_each(options = {})
+        self.query_as(:n).return(:n).find_each(:n, primary_key, options) do |batch|
+          yield batch.n
+        end
+      end
+
+      private
+
+      def exists_query_start(node_condition)
+        case node_condition
+        when Integer
+          self.query_as(:n).where('ID(n)' => node_condition)
+        when Hash
+          self.where(node_condition.keys.first => node_condition.values.first)
+        else
+          self.query_as(:n)
+        end
+      end
+    end
+  end
+end