pacer-neo4j2 2.0.1-java

data/lib/pacer-neo4j2/algo.rb

@@ -0,0 +1,406 @@
+module Pacer
+  module Core::Graph
+    module VerticesRoute
+      def path_to(to_v, opts = {})
+        route = self
+        route = make_pairs(to_v) if to_v.is_a? Enumerable
+        route.chain_route({transform: :path_finder, element_type: :path, max_hits: 1, target: to_v}.merge opts)
+      end
+
+      def paths_to(to_v, opts = {})
+        route = self
+        route = make_pairs(to_v) if to_v.is_a? Enumerable
+        route.chain_route({transform: :path_finder, element_type: :path, target: to_v}.merge opts)
+      end
+    end
+
+    module PathRoute
+      def expand(opts = {})
+        chain_route({transform: :path_finder, element_type: :path}.merge opts)
+      end
+    end
+  end
+
+
+  module Transform
+    module PathFinder
+      import org.neo4j.graphalgo.CommonEvaluators
+      import org.neo4j.graphalgo.GraphAlgoFactory
+      import org.neo4j.graphdb.Direction
+      import org.neo4j.kernel.Traversal
+      import org.neo4j.graphdb.DynamicRelationshipType
+      include Pacer::Neo4j2::Algo
+
+      def after_initialize
+        fail Pacer::ClientError, 'graph must be neo4j' unless graph.vendor == 'neo4j'
+      end
+
+      def help(opt = nil)
+        case opt
+when nil
+  puts <<HELP
+Finds paths between pairs of vertices. The algorithm used depends on the
+options specified. All supported path finding algorithms including in Neo4j 1.8
+are included, and all of their documented usages are possible.
+
+USAGE:
+
+vertices.path_to(targets, options = {})
+    Find the first path from each vertex to each target vertex
+
+vertices.paths_to(targets, options = {})
+    Find multiple paths from each vertex to each target vertex
+
+paths.expand(options = {})
+    Find multiple paths from the first vertex in each path to the last vertex
+    in each path.
+
+All options are optional!
+
+These methods only work on Neo4j graphs.
+
+More details:
+
+help :options      for simple path algorithms and other options
+  find_all, cyclical, length, max_depth, max_hits
+
+help :cost         for Dijkstra and aStar
+  cost, cost_property, cost_default
+
+help :estimate     for aStar
+  estimate, estimate_default, lat_property, long_property
+
+help :expansion    customize how any path is expanded
+  in_labels, out_labels, both_labels, expander, forward, reverse
+
+HELP
+when :path
+  puts <<HELP
+Details for path:         expander: proc { |path, state| edges }
+
+#end_v        Returns the end vertex of this path.
+#start_v      Returns the start vertex of this path.
+#length       Returns the length of this path.
+#path         Iterates through both the vertices and edges of this path in
+              order.
+#end_e        Returns the last edge in this path.
+#v            Returns all the vertices in this path starting from the start
+              vertex going forward towards the end vertex.
+#e            Returns all the edges in between the vertices which this path
+              consists of.
+#reverse_v    Like #v but reversed.
+#reverse_e    Like #e but reversed.
+
+The following methods all proxy to the vertex returned by #end_v: and behave
+exactly like standard Pacer Vertex methods.
+
+The iterators can be combined with the + operator.
+
+Fast edge iterators:
+  #out_edges(*args)
+  #in_edges(*args)
+  #both_edges(*args)
+
+Fast vertex iterators:
+  #out_vertices(*args)
+  #in_vertices(*args)
+  #both_vertices(*args)
+
+Edge routes:
+  #out_e(*args)
+  #in_e(*args)
+  #both_e(*args)
+
+Vertex routes:
+  #out(*args)
+  #in(*args)
+  #both(*args)
+
+HELP
+when :expansion
+  puts <<HELP
+Path expansion options:
+
+  By default, all edges will be followed. By specifying expansion rules you can
+  limit which paths are attempted. All algorithms use the same expanders so
+  these options do not effect the algorithm selection.
+
+  in_labels: label | [labels]    only follow : in edges  : with the given label(s)
+  out_labels:                                : out edges :
+  both_labels:                               : edges     :
+      These options can be combined.
+
+  Expanders search forward from the start vertex and backwards from the target
+  vertex. Either expander
+
+  expander: Proc | PathExpander   Custom rule for forward search
+      If no reverse is specified, will be used for reverse too.
+  forward:                        synonym for the expander option
+  reverse:  Proc | PathExpander   Custom rule for the reverse search
+
+      proc { |path, state| edges }:
+        path is a Pacer::Neo4j2::Algo::PathWrapper - help(:path) for details
+        The proc must simply return an Enumerable of edges that the
+
+HELP
+when :options
+  puts <<HELP
+Simple options:
+
+  find_all: Boolean    Find all non-cyclical paths.
+      Algorithm: allSimplePaths
+
+  cyclical: Boolean    Find all paths including cyclical ones.
+      Algorithm: allPaths
+
+  length: Number       Number of edges that the path contains.
+      Algorithm: pathsWithLength
+      Returns only paths of the specified length.
+
+  max_depth: Number    Number of edges to search in a potential path.
+      Default: 5
+      Limits how many edges will be traversed searching for a path. Higher
+      numbers can take exponentially longer, I think.  Does not apply to aStar,
+      Dijkstra, or pathsWithLength algorithms.
+
+      Required for find_all, cyclical, and shortest path algorithms.
+
+  max_hits: Number     Maximum number of paths to find for each pair of vertices.
+      #path_to defaults this to 1. All algorithms use this but only
+      some support it natively in Neo4j's implementations.
+
+
+HELP
+when :cost
+  puts <<HELP
+Cost options:
+
+  Specifying these chooses the Dijkstra algorithm unless an estimate is also
+  specified.
+
+  cost: Proc | CostEvaluator   Calculate the cost for this edge.
+      Must return a Numeric unless cost_default is set.
+      proc { |edge, direction| Float }:
+        direction is either :in or :out.
+
+  cost_property: String        get the cost from the given edge property
+  cost_default: Float          default if the property isn't there
+
+HELP
+when :estimate
+  puts <<HELP
+Estimate options
+  Specifying these together with cost chooses the a* / aStar algorithm.
+
+  estimate:
+      Must return a Numeric unless estimate_default is set.
+      proc { |vertex, goal_vertex| Float }
+
+  estimate_default: Float   only works with the proc estimate
+
+  lat_property: String      latitude property name
+  long_property: String     longitude property name
+      Use latitude and longitude if all estimated vertices have the necessary
+      properties.
+
+HELP
+else
+  super
+end
+        description
+      end
+
+      def method
+        if has_cost?
+          if has_estimate?
+            :aStar
+          else
+            :dijkstra
+          end
+        elsif cyclical and max_depth
+          :all
+        elsif find_all and max_depth
+          :all_simple
+        elsif length
+          :with_length
+        elsif max_depth
+          if max_hits
+            :shortest_with_max_hits
+          else
+            :shortest
+          end
+        end
+      end
+
+      attr_accessor :target
+
+      # specify one or many edge labels that the path may take in the given direction
+      attr_accessor :in_labels, :out_labels, :both_labels
+
+      # note that expander procs *must* return edge(s) that are connected to the end_v of the given path
+      #
+      # expander yields: { |path, state| path.is_a? Pacer::Neo4j2::Algo::PathWrapper }
+      attr_accessor :expander, :forward, :reverse
+
+      # use dijkstra unless the below estimate properties are set
+      #
+      # note that cost proc must return a Numeric unless cost_default is set
+      #
+      # cost yields: { |edge, direction| [:in, :out, :both].include? direction }
+      attr_accessor :cost, :cost_property, :cost_default
+
+      def set_cost(property = nil, default = nil, &block)
+        self.cost_property = property
+        self.cost_default = default
+        self.cost = block
+        self
+      end
+
+      # use the aStar algorithm
+      #
+      # note that estimate proc must return a Numeric unless estimate_default is set
+      #
+      # estimate yields: { |vertex, goal_vertex| }
+      attr_accessor :estimate, :lat_property, :long_property, :estimate_default
+
+      def set_estimate(lat = nil, long = nil, &block)
+        self.lat_property = lat
+        self.long_property = long
+        self.estimate = block
+        self
+      end
+
+      # use pathsWithLength
+      #
+      # Return only paths of the given length
+      attr_accessor :length
+
+      # default to shortest_path unless find_all is set
+      attr_writer :max_depth
+      def max_depth
+        @max_depth || 5
+      end
+
+      # use shortestPath
+      attr_accessor :max_hits
+
+      # Possible values:
+      attr_accessor :find_all
+      attr_accessor :cyclical
+
+      protected
+
+      def attach_pipe(end_pipe)
+        if back and back.element_type == :path
+          p = PathFromPathPipe.new build_algo, graph, max_hits
+        else
+          p = PathPipe.new build_algo, graph, target, max_hits
+        end
+        p.setStarts end_pipe
+        attach_length_filter(p) if length and method != :with_length
+        p
+      end
+
+      def attach_length_filter(end_pipe)
+        pipe = Pacer::Pipes::BlockFilterPipe.new(self, proc { |p| p.length == length }, false)
+        pipe.set_starts end_pipe if end_pipe
+        pipe
+      end
+
+      def inspect_string
+        if back and back.element_type == :path
+          "expand[#{method}](max_depth: #{ max_depth })"
+        else
+          "paths_to[#{method}](#{ target.inspect }, max_depth: #{ max_depth })"
+        end
+      end
+
+      private
+
+      def has_cost?
+        cost or cost_property or cost_default
+      end
+
+      def has_estimate?
+        estimate or (lat_property and long_property) or estimate_default
+      end
+
+      def build_algo
+        case method
+        when :aStar
+          GraphAlgoFactory.aStar build_expander, build_cost, build_estimate
+        when :dijkstra
+          GraphAlgoFactory.dijkstra build_expander, build_cost
+        when :with_length
+          GraphAlgoFactory.pathsWithLength build_expander, length
+        when :all
+          GraphAlgoFactory.allPaths build_expander, max_depth
+        when :all_simple
+          GraphAlgoFactory.allSimplePaths build_expander, max_depth
+        when :shortest_with_max_hits
+          GraphAlgoFactory.shortestPath build_expander, max_depth, max_hits
+        when :shortest
+          GraphAlgoFactory.shortestPath build_expander, max_depth
+        when nil
+          fail Pacer::ClientError, "Could not choose a path algorithm"
+        else
+          fail Pacer::LogicError, "Unable to build algo for #{ method }"
+        end
+      end
+
+      def build_expander
+        if forward.is_a? Proc and reverse.is_a? Proc
+          BlockPathExpander.new forward, reverse, graph, max_depth
+        elsif expander.is_a? Proc
+          BlockPathExpander.new expander, expander, graph, max_depth
+        elsif expander
+          expander
+        else
+          e = Traversal.emptyExpander
+          [*out_labels].each do |label|
+            e = e.add DynamicRelationshipType.withName(label.to_s), Direction::OUTGOING
+          end
+          [*in_labels].each do |label|
+            e = e.add DynamicRelationshipType.withName(label.to_s), Direction::INCOMING
+          end
+          [*both_labels].each do |label|
+            e = e.add DynamicRelationshipType.withName(label.to_s), Direction::BOTH
+          end
+          e
+        end
+      end
+
+      def build_cost
+        if cost.is_a? Proc
+          BlockCostEvaluator.new cost, graph, cost_default
+        elsif cost
+          cost
+        elsif cost_property
+          if cost_default
+            CommonEvaluators.doubleCostEvaluator cost_property.to_s, cost_default.to_f
+          else
+            CommonEvaluators.doubleCostEvaluator cost_property.to_s
+          end
+        elsif cost_default
+          CommonEvaluators.doubleCostEvaluator ' not a property ', cost_default.to_f
+        else
+          fail Pacer::LogicError, "could not build cost"
+        end
+      end
+
+      def build_estimate
+        if estimate.is_a? Proc
+          BlockEstimateEvaluator.new estimate, graph, estimate_default
+        elsif estimate
+          estimate
+        elsif lat_property and long_property
+          CommonEvaluators.geoEstimateEvaluator lat_property.to_s, long_property.to_s
+        elsif estimate_default
+          BlockEstimateEvaluator.new proc { estimate_default }, graph, estimate_default
+        else
+          fail Pacer::LogicError, "could not build estimate"
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j2/blueprints_graph.rb

@@ -0,0 +1,42 @@
+module Pacer
+  module Neo4j2
+    class BlueprintsGraph < com.tinkerpop.blueprints.impls.neo4j2.Neo4j2Graph
+      attr_accessor :allow_auto_tx, :allow_auto_read_tx
+
+      # Threadlocal tx_depth is set in Pacer's graph_transaction_mixin.rb
+      def tx_depth
+        graphs = Thread.current[:graphs] ||= {}
+        tgi = graphs[object_id] ||= {}
+        tgi[:tx_depth] || 0
+      end
+
+      # Threadlocal read_tx_depth is set in Pacer's graph_transaction_mixin.rb
+      def read_tx_depth
+        graphs = Thread.current[:graphs] ||= {}
+        tgi = graphs[object_id] ||= {}
+        depth = tgi[:read_tx_depth] || 0
+        if depth == 0
+          tgi[:tx_depth] || 0 # Reads are allowed in any type of tx.
+        else
+          depth
+        end
+      end
+
+      def autoStartTransaction(for_write)
+        if for_write
+          if allow_auto_tx or tx_depth != 0
+            super
+          else
+            raise Pacer::TransactionError, "Can't mutate the graph outside a transaction block"
+          end
+        else
+          if allow_auto_read_tx or read_tx_depth != 0
+            super
+          else
+            raise Pacer::TransactionError, "Can't read the graph outside a transaction or read_transaction block"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j2/graph.rb

@@ -0,0 +1,243 @@
+require 'set'
+
+module Pacer
+  module Neo4j2
+    class Graph < PacerGraph
+      JDate = java.util.Date
+      import java.text.SimpleDateFormat
+
+      # I'm not sure exactly what this impacts but if it is false, many Pacer tests fail.
+      #
+      # Presumably Neo4j is faster with it set to false.
+      def safe_transactions=(b)
+        blueprints_graph.setCheckElementsInTransaction b
+      end
+
+      def safe_transactions
+        blueprints_graph.getCheckElementsInTransaction
+      end
+
+      def allow_auto_tx=(b)
+        blueprints_graph.allow_auto_tx = b
+      end
+
+      def allow_auto_tx
+        blueprints_graph.allow_auto_tx
+      end
+
+      def allow_auto_read_tx=(b)
+        blueprints_graph.allow_auto_read_tx = b
+      end
+
+      def allow_auto_read_tx
+        blueprints_graph.allow_auto_read_tx
+      end
+
+      def cypher(query)
+        [query].to_route(element_type: :string, graph: self).cypher
+      end
+
+      def key_index_cache(type, name, size = :undefined)
+        indexer = lucene_auto_index(type)
+        if size == :undefined
+          indexer.getCacheCapacity name
+        else
+          indexer.setCacheCapacity name, size
+        end
+      end
+
+      # When a Neo4J graph is restarted, the ids of any elements that were deleted
+      # will be reused. Running this code immediately after starting the graph
+      # prevents Neo4J from reusing those IDs.
+      def prevent_id_reuse!
+        {
+          edges: prevent_edge_id_reuse!,
+          vertices: prevent_vertex_id_reuse!
+        }
+      end
+
+      # This works by simply creating IDs until the ID of a new element is greater than
+      # either the max existing ID, or the min_new_id argument.
+      def prevent_vertex_id_reuse!(min_new_id = nil)
+        min_new_id ||= v.element_ids.max
+        return unless min_new_id
+        g = blueprints_graph
+        n = 0
+        transaction do |_, rollback|
+          begin
+            n += 1
+            v = g.addVertex(nil)
+          end while v.getId < min_new_id
+          rollback.call
+        end
+        n
+      end
+
+      def prevent_edge_id_reuse!(min_new_id = nil)
+        min_new_id ||= e.element_ids.max
+        return unless min_new_id
+        g = blueprints_graph
+        n = 0
+        transaction do |_, rollback|
+          v1 = g.addVertex nil
+          v2 = g.addVertex nil
+          begin
+            n += 1
+            e = g.addEdge(nil, v1, v2, "temp")
+          end while e.getId < min_new_id
+          rollback.call
+        end
+        n
+      end
+
+      def neo_graph
+        blueprints_graph.raw_graph
+      end
+
+      def reopen_read_transaction
+        blueprints_graph.autoStartTransaction(false) if in_read_transaction?
+      end
+
+      def on_commit(&block)
+        return unless block
+        TransactionEventHandler.new(self).tap do |h|
+          h.on_commit = block
+          neo_graph.registerTransactionEventHandler h
+        end
+      end
+
+      # This is actually only called if the commit fails and then it internally tries to
+      # rollback. It seems that it's actually possible for it to fail to rollback here, too...
+      #
+      # An exception in before_commit can definitely trigger this.
+      #
+      # Regular rollbacks do not get seen by the transaction system and no callback happens.
+      def on_commit_failed(&block)
+        return unless block
+        TransactionEventHandler.new(self).tap do |h|
+          h.on_commit_failed = block
+          neo_graph.registerTransactionEventHandler h
+        end
+      end
+
+      def before_commit(&block)
+        return unless block
+        TransactionEventHandler.new(self).tap do |h|
+          h.before_commit = block
+          neo_graph.registerTransactionEventHandler h
+        end
+      end
+
+      def drop_handler(h)
+        neo_graph.unregisterTransactionEventHandler h
+      end
+
+      # Creates a Blueprints key index without doing a rebuild.
+      def create_key_index_fast(name, type = :vertex)
+        raise "Invalid index type #{ type }" unless [:vertex, :edge].include? type
+        keys = (key_indices(type) + [name.to_s]).to_a
+        neo_settings = neo_graph.getNodeManager.getGraphProperties
+        iz = neo_graph.index.getNodeAutoIndexer
+        prop = ((type == :vertex) ? "Vertex:indexed_keys" : "Edge:indexed_keys")
+        transaction do
+          create_vertex.delete! # this forces Blueprints to actually start the transaction
+          neo_settings.setProperty prop, keys.to_java(:string)
+          keys.each do |key|
+            iz.startAutoIndexingProperty key
+          end
+        end
+      end
+
+
+      private
+
+      def index_properties(type, filters)
+        filters.properties.select { |k, v| key_indices(type).include?(k) and not v.nil? }
+      end
+
+      def lucene_set(k, v)
+        statements = v.map { |x| "#{k}:#{lucene_value(x)}" }
+        "(#{ statements.join(' OR ') })"
+      end
+
+      def lucene_range(k, v)
+        if v.min and v.max
+          encoded = encode_property(v.min)
+          if encoded.is_a? JDate
+            "#{k}:[#{lucene_value v.min} TO #{lucene_value v.max}]"
+          else
+            "#{k}:[#{lucene_value v.min} TO #{lucene_value v.max}]"
+          end
+        end
+      end
+
+      def build_query(type, filters)
+        indexed = index_properties type, filters
+        if indexed.any?
+          indexed.map do |k, v|
+            k = k.to_s.gsub '/', '\\/'
+            if v.is_a? Range
+              lucene_range(k, v)
+            elsif v.class.name == 'RangeSet'
+              s = v.ranges.map { |r| lucene_range(k, r) }.join " OR "
+              "(#{s})"
+            elsif v.is_a? Set
+              lucene_set(k, v)
+            else
+              "#{k}:#{lucene_value v}"
+            end
+          end.compact.join " AND "
+        else
+          nil
+        end
+      end
+
+      def lucene_value(v)
+        s = encode_property(v)
+        if s.is_a? JDate
+          f = SimpleDateFormat.new 'yyyyMMddHHmmssSSS'
+          f.format s
+        elsif s
+          if s.is_a? String
+            s.inspect
+          else s
+            s
+          end
+        else
+          'NULL'
+        end
+      end
+
+      def lucene_auto_index(type)
+        if type == :vertex
+          indexer = neo_graph.index.getNodeAutoIndexer
+        elsif type == :edge
+          indexer = neo_graph.index.getRelationshipAutoIndexer
+        end
+        indexer.getAutoIndex
+      end
+
+      def indexed_route(element_type, filters, block)
+        if search_manual_indices
+          super
+        else
+          filters.graph = self
+          filters.use_lookup!
+          query = build_query(element_type, filters)
+          if query
+            route = lucene query, element_type: element_type, extensions: filters.extensions, wrapper: filters.wrapper
+            filters.remove_property_keys key_indices(element_type)
+            if filters.any?
+              Pacer::Route.property_filter(route, filters, block)
+            else
+              route
+            end
+          elsif filters.route_modules.any?
+            mod = filters.route_modules.shift
+            Pacer::Route.property_filter(mod.route(self), filters, block)
+          end
+        end
+      end
+    end
+  end
+end