activegraph 11.0.0.beta.1-java

data/lib/active_graph/node/query/query_proxy_eager_loading/association_tree.rb

@@ -0,0 +1,75 @@
+module ActiveGraph
+  module Node
+    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/active_graph/node/query/query_proxy_enumerable.rb

@@ -0,0 +1,110 @@
+module ActiveGraph
+  module Node
+    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 = ActiveGraph::Node::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?(ActiveGraph::Relationship)
+              object.last.instance_variable_set(association.direction == :in ? '@from_node' : '@to_node', object.first)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph/node/query/query_proxy_find_in_batches.rb

@@ -0,0 +1,19 @@
+module ActiveGraph
+  module Node
+    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 { |record| record[identity] }
+          end
+        end
+
+        def find_each(options = {})
+          query.return(identity).find_each(identity, @model.primary_key, options) do |result|
+            yield result[identity]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph/node/query/query_proxy_link.rb

@@ -0,0 +1,139 @@
+module ActiveGraph
+  module Node
+    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?(ActiveGraph::Node)
+                      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

data/lib/active_graph/node/query/query_proxy_methods.rb

@@ -0,0 +1,303 @@
+module ActiveGraph
+  module Node
+    module Query
+      # rubocop:disable Metrics/ModuleLength
+      module QueryProxyMethods
+        # rubocop:enable Metrics/ModuleLength
+        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
+
+        def as(node_var)
+          new_link(node_var)
+        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
+
+        def distinct
+          new_link.tap do |e|
+            e.instance_variable_set(:@distinct, true)
+          end
+        end
+
+        def propagate_context(query_proxy)
+          query_proxy.instance_variable_set(:@distinct, @distinct)
+        end
+
+        # @return [Integer] number of nodes of this class
+        def count(distinct = nil, target = nil)
+          return 0 if unpersisted_start_object?
+          fail(ActiveGraph::InvalidParameterError, ':count accepts the `:distinct` symbol or nil as a parameter') unless distinct.nil? || distinct == :distinct
+          query_with_target(target) do |var|
+            q = ensure_distinct(var, !distinct.nil?)
+            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?(ActiveGraph::Core::QueryClauses::LimitClause) }
+          limit_clause.instance_variable_get(:@arg)
+        end
+
+        def empty?(target = nil)
+          return true if unpersisted_start_object?
+          query_with_target(target) { |var| !self.exists?(nil, var) }
+        end
+
+        alias blank? empty?
+
+        # @param [ActiveGraph::Node, ActiveGraph::Node, String] other An instance of a Neo4j.rb model, a 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) || association_id_key == :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].positive?
+          end
+        end
+
+        def exists?(node_condition = nil, target = nil)
+          unless [Integer, String, Hash, NilClass].any? { |c| node_condition.is_a?(c) }
+            fail(ActiveGraph::InvalidParameterError, ':exists? only accepts ids or conditions')
+          end
+          query_with_target(target) do |var|
+            start_q = exists_query_start(node_condition, var)
+            result = start_q.query.reorder.return("ID(#{var}) AS proof_of_life LIMIT 1").first
+            !!result
+          end
+        end
+
+        # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id}`
+        # The `node` param can be a persisted Node 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 [ActiveGraph::Node::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 (Relationship, 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 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?
+          ActiveGraph::Base.transaction do
+            node = model.create(params)
+            self << node
+            node
+          end
+        end
+
+        def find_or_initialize_by(attributes, &block)
+          find_by(attributes) || initialize_by_current_chain_params(attributes, &block)
+        end
+
+        def first_or_initialize(attributes = {}, &block)
+          first || initialize_by_current_chain_params(attributes, &block)
+        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 Node 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
+
+        # Matches all nodes having at least a relation
+        #
+        # @example Load all people having a friend
+        #   Person.all.having_rel(:friends).to_a # => Returns a list of `Person`
+        #
+        # @example Load all people having a best friend
+        #   Person.all.having_rel(:friends, best: true).to_a # => Returns a list of `Person`
+        #
+        # @return [QueryProxy] A new QueryProxy
+        def having_rel(association_name, rel_properties = {})
+          association = association_or_fail(association_name)
+          where("(#{identity})#{association.arrow_cypher(nil, rel_properties)}()")
+        end
+
+        # Matches all nodes not having a certain relation
+        #
+        # @example Load all people not having friends
+        #   Person.all.not_having_rel(:friends).to_a # => Returns a list of `Person`
+        #
+        # @example Load all people not having best friends
+        #   Person.all.not_having_rel(:friends, best: true).to_a # => Returns a list of `Person`
+        #
+        # @return [QueryProxy] A new QueryProxy
+        def not_having_rel(association_name, rel_properties = {})
+          association = association_or_fail(association_name)
+          where_not("(#{identity})#{association.arrow_cypher(nil, rel_properties)}()")
+        end
+
+        private
+
+        def association_or_fail(association_name)
+          model.associations[association_name] || fail(ArgumentError, "No such association #{association_name}")
+        end
+
+        def find_inverse_association!(model, source, association)
+          model.associations.values.find do |reverse_association|
+            association.inverse_of?(reverse_association) ||
+              reverse_association.inverse_of?(association) ||
+              inverse_relation_of?(source, association, model, reverse_association)
+          end || fail("Could not find reverse association for #{@context}")
+        end
+
+        def inverse_relation_of?(source, source_association, target, target_association)
+          source_association.direction != target_association.direction &&
+            source == target_association.target_class &&
+            target == source_association.target_class &&
+            source_association.relationship_class_name == target_association.relationship_class_name
+        end
+
+        def initialize_by_current_chain_params(params = {})
+          result = new(where_clause_params.merge(params))
+
+          inverse_association = find_inverse_association!(model, source_object.class, association) if source_object
+          result.tap do |m|
+            yield(m) if block_given?
+            m.public_send(inverse_association.name) << source_object if inverse_association
+          end
+        end
+
+        def where_clause_params
+          query.clauses.select { |c| c.is_a?(ActiveGraph::Core::QueryClauses::WhereClause) && c.arg.is_a?(Hash) }
+               .map! { |e| e.arg[identity] }.compact.inject { |a, b| a.merge(b) } || {}
+        end
+
+        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
+                                    ord_prop = (func == LAST ? {order_property => :DESC} : order_property)
+                                    [self.order(ord_prop).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)
+          when String
+            self.where(model.primary_key => condition)
+          else
+            self
+          end
+        end
+      end
+    end
+  end
+end