pacer-neo4j 2.1.0-java → 2.1.1-java

data/lib/pacer-neo4j.rb

@@ -8,15 +8,20 @@ require 'pacer-neo4j/version'
 require Pacer::Neo4j::JAR
 
 require 'pacer-neo4j/graph'
+require 'pacer-neo4j/algo/wrapping'
 require 'pacer-neo4j/algo/path_pipe'
 require 'pacer-neo4j/algo/block_cost_evaluator'
 require 'pacer-neo4j/algo/block_estimate_evaluator'
 require 'pacer-neo4j/algo/block_path_expander'
 require 'pacer-neo4j/algo/path_wrapper'
 require 'pacer-neo4j/algo/traversal_branch_wrapper'
+require 'pacer-neo4j/algo/cypher_transform'
 require 'pacer-neo4j/algo'
 require 'pacer-neo4j/raw_vertex_wrapping_pipe'
 require 'pacer-neo4j/lucene_filter'
+require 'pacer-neo4j/transaction_event_handler'
+require 'pacer-neo4j/tx_data_wrapper'
+require 'pacer-neo4j/blueprints_graph'
 
 Pacer::FunctionResolver.clear_cache
 
@@ -37,18 +42,20 @@ module Pacer
     # `graph.setCheckElementsInTransaction(false)` to disable the
     # feature.
     def neo4j(path_or_graph, args = nil)
-      bp_neo_class = com.tinkerpop.blueprints.impls.neo4j.Neo4jGraph
       if path_or_graph.is_a? String
         path = File.expand_path(path_or_graph)
         open = proc do
-          graph = Pacer.open_graphs[path]
-          unless graph
+          raw_graph = Pacer.open_graphs[path]
+          if raw_graph
+            graph = Pacer::Neo4j::BlueprintsGraph.new(raw_graph)
+          else
             if args
-              graph = bp_neo_class.new(path, args.to_hash_map)
+              graph = Pacer::Neo4j::BlueprintsGraph.new(path, args.to_hash_map)
             else
-              graph = bp_neo_class.new(path)
+              graph = Pacer::Neo4j::BlueprintsGraph.new(path)
             end
-            Pacer.open_graphs[path] = graph
+            graph.allow_auto_tx = true
+            Pacer.open_graphs[path] = graph.raw_graph
             graph.setCheckElementsInTransaction true
           end
           graph
@@ -60,7 +67,7 @@ module Pacer
         Neo4j::Graph.new(Pacer::YamlEncoder, open, shutdown)
       else
         # Don't register the new graph so that it won't be automatically closed.
-        Neo4j::Graph.new Pacer::YamlEncoder, proc { bp_neo_class.new(path_or_graph) }
+        Neo4j::Graph.new Pacer::YamlEncoder, proc { Pacer::Neo4j::BlueprintsGraph.new(path_or_graph) }
       end
     end
 

data/lib/pacer-neo4j/algo.rb

@@ -291,7 +291,7 @@ end
       protected
 
       def attach_pipe(end_pipe)
-        if back.element_type == :path
+        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
@@ -308,7 +308,7 @@ end
       end
 
       def inspect_string
-        if back.element_type == :path
+        if back and back.element_type == :path
           "expand[#{method}](max_depth: #{ max_depth })"
         else
           "paths_to[#{method}](#{ target.inspect }, max_depth: #{ max_depth })"

data/lib/pacer-neo4j/algo/cypher_transform.rb

@@ -0,0 +1,129 @@
+module Pacer
+  module Core
+    module StringRoute
+      def raw_cypher(opts = {})
+        chain_route({element_type: :cypher, transform: Pacer::Transform::Cypher}.merge opts)
+      end
+
+      def cypher(opts = {})
+        raw_cypher(opts).paths
+      end
+    end
+
+    module Graph
+      module VerticesRoute
+        def raw_cypher(query, elements_per_query = nil)
+          reducer(element_type: :array).
+            enter { Set[] }.
+            leave { |x, a| x.nil? or (elements_per_query and a.length % elements_per_query == 0) }.
+            reduce { |v, ids| ids << v.element_id }.
+          map(element_type: :string) { |a| "start v=node(#{a.to_a.join(',')}) #{ query }"}.
+            raw_cypher
+        end
+
+        def cypher(query, elements_per_query = nil)
+          raw_cypher(query, elements_per_query).paths
+        end
+      end
+    end
+
+    module CypherRoute
+      def paths(*columns)
+        chain_route element_type: :path, transform: Pacer::Transform::CypherResults, columns: columns
+      end
+
+      def v(column = nil)
+        chain_route element_type: :vertex, transform: Pacer::Transform::CypherResults, columns: [column].compact, single: true
+      end
+
+      def e(column = nil)
+        chain_route element_type: :edge, transform: Pacer::Transform::CypherResults, columns: [column].compact, single: true
+      end
+
+      def results(*columns)
+        chain_route element_type: :array, transform: Pacer::Transform::CypherResults, columns: columns
+      end
+    end
+    Pacer::RouteBuilder.current.element_types[:cypher] = [CypherRoute]
+  end
+
+  module Transform
+    module Cypher
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = CypherPipe.new(self)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      class CypherPipe < Pacer::Pipes::RubyPipe
+        import org.neo4j.cypher.javacompat.ExecutionEngine
+
+        attr_reader :engine
+
+        def initialize(route)
+          super()
+          graph = route.graph.neo_graph
+          @engine = ExecutionEngine.new graph
+        end
+
+        protected
+
+        def processNextStart
+          engine.execute starts.next
+        end
+      end
+    end
+
+    module CypherResults
+      attr_accessor :columns, :single
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = ResultsPipe.new(self, columns, single)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      class ResultsPipe < Pacer::Pipes::RubyPipe
+        import org.neo4j.cypher.javacompat.ExecutionEngine
+
+        include Pacer::Neo4j::Algo::Wrapping
+
+        attr_reader :columns, :graph, :single
+        attr_accessor :current
+
+        def initialize(route, columns, single)
+          super()
+          @single = single
+          @graph = route.graph
+          @columns = columns if columns and columns.any?
+        end
+
+        protected
+
+        def processNextStart
+          while true
+            if current
+              if current.first.hasNext
+                if single
+                  return wrap_path(current.map(&:next)).first
+                else
+                  return wrap_path current.map(&:next)
+                end
+              else
+                self.current = nil
+              end
+            else
+              results = starts.next
+              cols = columns || results.columns.to_a
+              self.current = cols.map { |col| results.columnAs col }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/algo/path_wrapper.rb

@@ -6,9 +6,7 @@ module Pacer
       #
       # Note that I have removed methods that I didn't understand, assuming they are internal.
       class PathWrapper
-        import org.neo4j.graphdb.Node
-        import com.tinkerpop.blueprints.impls.neo4j.Neo4jVertex
-        import com.tinkerpop.blueprints.impls.neo4j.Neo4jEdge
+        include Wrapping
 
         attr_reader :graph, :raw_path
 
@@ -26,13 +24,7 @@ module Pacer
 
         # Iterates through both the vertices and edges of this path in order.
         def path
-          raw_path.iterator.to_route.map(graph: graph, element_type: :mixed) do |e|
-            if e.is_a? Node
-              wrap_vertex e
-            else
-              wrap_edge e
-            end
-          end
+          wrap_path raw_path.iterator
         end
 
         def to_a
@@ -136,16 +128,6 @@ module Pacer
         def both(*args)
           end_v.both(*args)
         end
-
-        private
-
-        def wrap_vertex(v)
-          Pacer::Wrappers::VertexWrapper.new graph, Neo4jVertex.new(v, graph.blueprints_graph)
-        end
-
-        def wrap_edge(e)
-          Pacer::Wrappers::EdgeWrapper.new graph, Neo4jEdge.new(e, graph.blueprints_graph)
-        end
       end
     end
   end

data/lib/pacer-neo4j/algo/wrapping.rb

@@ -0,0 +1,34 @@
+module Pacer
+  module Neo4j
+    module Algo
+      module Wrapping
+        import org.neo4j.graphdb.Node
+        import org.neo4j.graphdb.Relationship
+        import com.tinkerpop.blueprints.impls.neo4j.Neo4jVertex
+        import com.tinkerpop.blueprints.impls.neo4j.Neo4jEdge
+
+        private
+
+        def wrap_path(p)
+          p.collect do |e|
+            if e.is_a? Node
+              wrap_vertex e
+            elsif e.is_a? Relationship
+              wrap_edge e
+            else
+              e
+            end
+          end
+        end
+
+        def wrap_vertex(v)
+          Pacer::Wrappers::VertexWrapper.new graph, Neo4jVertex.new(v, graph.blueprints_graph)
+        end
+
+        def wrap_edge(e)
+          Pacer::Wrappers::EdgeWrapper.new graph, Neo4jEdge.new(e, graph.blueprints_graph)
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/blueprints_graph.rb

@@ -0,0 +1,28 @@
+module Pacer
+  module Neo4j
+    class BlueprintsGraph < com.tinkerpop.blueprints.impls.neo4j.Neo4jGraph
+      attr_accessor :allow_auto_tx
+      attr_reader :tx_depth
+
+      def initialize(*args)
+        super
+        @tx_depth = 0
+      end
+
+      def transaction
+        @tx_depth += 1
+        yield
+      ensure
+        @tx_depth -= 1
+      end
+
+      def autoStartTransaction
+        if tx_depth != 0 or allow_auto_tx
+          super
+        else
+          raise Pacer::TransactionError, "Can't mutate the graph outside a transaction block"
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/graph.rb

@@ -1,6 +1,9 @@
 module Pacer
   module Neo4j
     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.
@@ -12,14 +15,71 @@ module Pacer
         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 transaction(*args, &block)
+        blueprints_graph.transaction do
+          super
+        end
+      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
-          lucene_auto_index(type).getCacheCapacity name
+          indexer.getCacheCapacity name
         else
-          lucene_auto_index(type).setCacheCapacity name, size
+          indexer.setCacheCapacity name, size
+        end
+      end
+
+      def neo_graph
+        blueprints_graph.raw_graph
+      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
+
       private
 
       def index_properties(type, filters)
@@ -30,15 +90,16 @@ module Pacer
         indexed = index_properties type, filters
         if indexed.any?
           indexed.map do |k, v|
-            if v.is_a? Numeric
-              "#{k}:#{v}"
-            else
-              s = encode_property(v)
-              if s.is_a? String and s =~ /\s/
-                %{#{k}:"#{s}"}
+            k = k.to_s.gsub '/', '\\/'
+            if v.is_a? Range
+              encoded = encode_property(v.min)
+              if encoded.is_a? JDate
+                "#{k}:[#{lucene_value v.min} TO #{lucene_value v.max}]"
               else
-                "#{k}:#{s}"
+                "#{k}:{#{lucene_value v.min} TO #{lucene_value v.max}}"
               end
+            else
+              "#{k}:#{lucene_value v}"
             end
           end.join " AND "
         else
@@ -46,16 +107,29 @@ module Pacer
         end
       end
 
-      def neo_graph
-        blueprints_graph.raw_graph
+      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 and s =~ /[\t :"']/
+            s.inspect
+          else s
+            s
+          end
+        else
+          'NULL'
+        end
       end
 
       def lucene_auto_index(type)
         if type == :vertex
-          neo_graph.index.getNodeAutoIndexer.getIndexInternal
+          indexer = neo_graph.index.getNodeAutoIndexer
         elsif type == :edge
-          neo_graph.index.getRelationshipAutoIndexer.getIndexInternal
+          indexer = neo_graph.index.getRelationshipAutoIndexer
         end
+        indexer.getAutoIndex
       end
 
       def indexed_route(element_type, filters, block)
@@ -64,7 +138,7 @@ module Pacer
         else
           query = build_query(element_type, filters)
           if query
-            route = lucene query, element_type: element_type
+            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)

data/lib/pacer-neo4j/transaction_event_handler.rb

@@ -0,0 +1,40 @@
+module Pacer
+  module Neo4j
+    class TransactionEventHandler
+      include org.neo4j.graphdb.event.TransactionEventHandler
+
+      attr_reader :graph
+      attr_accessor :on_commit, :on_commit_failed, :before_commit
+
+      def initialize(graph)
+        @graph = graph
+      end
+
+      def unregister!
+        graph.drop_handler self
+      end
+
+      private
+
+      # Return value is passed to afterCommit or afterRollback, but some values can cause crashes.
+      def beforeCommit(data)
+        before_commit.call TxDataWrapper.new data, graph if before_commit
+        nil
+      end
+
+      def afterCommit(data, ignore)
+        on_commit.call TxDataWrapper.new data, graph if on_commit
+      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 beforeCommit can definitely trigger this.
+      #
+      # Regular rollbacks do not get seen by the transaction system and no callback happens.
+      def afterRollback(data, ignore)
+        on_commit_failed.call TxDataWrapper.new data, graph if on_commit_failed
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/tx_data_wrapper.rb

@@ -0,0 +1,100 @@
+module Pacer
+  module Neo4j
+    # Uses the interface defined here:
+    # http://api.neo4j.org/1.8/org/neo4j/graphdb/Path.html
+    #
+    # Note that I have removed methods that I didn't understand, assuming they are internal.
+    class TxDataWrapper
+      include Algo::Wrapping
+
+      attr_reader :graph, :tx
+
+      def initialize(tx, graph)
+        @tx = tx
+        @graph = graph
+      end
+
+      def created_v
+        tx.createdNodes.map { |n| wrap_vertex n }
+      end
+
+      def deleted_v
+        tx.deletedNodes.map { |n| wrap_vertex n }
+      end
+
+      def created_e
+        tx.createdRelationships.map { |n| wrap_edge n }
+      end
+
+      def deleted_e
+        tx.deletedRelationships.map { |n| wrap_edge n }
+      end
+
+      def created_v_ids
+        tx.createdNodes.map { |n| n.getId }
+      end
+
+      def deleted_v_ids
+        tx.deletedNodes.map { |n| n.getId }
+      end
+
+      def created_e_ids
+        tx.createdRelationships.map { |n| n.getId }
+      end
+
+      def deleted_e_ids
+        tx.deletedRelationships.map { |n| n.getId }
+      end
+
+      def deleted?(e)
+        tx.is_deleted e.element.rawElement
+      end
+
+      def changed_v
+        tx.assignedNodeProperties.map do |p|
+          { element_type: :vertex,
+            id: p.entity.getId,
+            key: p.key,
+            was: graph.decode_property(p.previouslyCommitedValue),
+            is: graph.decode_property(p.value) }
+        end +
+        tx.removedNodeProperties.map do |p|
+          { element_type: :vertex,
+            id: p.entity.getId,
+            key: p.key,
+            was: graph.decode_property(p.previouslyCommitedValue),
+            is: nil }
+        end
+      end
+
+      def changed_e
+        tx.assignedRelationshipProperties.map do |p|
+          { element_type: :edge,
+            id: p.entity.getId,
+            key: p.key,
+            was: graph.decode_property(p.previouslyCommitedValue),
+            is: graph.decode_property(p.value) }
+        end +
+        tx.removedRelationshipProperties.map do |p|
+          { element_type: :edge,
+            id: p.entity.getId,
+            key: p.key,
+            was: graph.decode_property(p.previouslyCommitedValue),
+            is: nil }
+        end
+      end
+
+      def changes
+        changed_v + changed_e
+      end
+
+      def summary
+        { created_v: created_v_ids,
+          deleted_v: deleted_v_ids,
+          created_e: created_e_ids,
+          deleted_e: deleted_e_ids,
+          changes: changes }
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/version.rb

@@ -1,10 +1,10 @@
 module Pacer
   module Neo4j
-    VERSION = "2.1.0"
+    VERSION = "2.1.1"
     JAR = "pacer-neo4j-#{ VERSION }-standalone.jar"
     JAR_PATH = "lib/#{ JAR }"
-    BLUEPRINTS_VERSION = "2.1.0"
-    PIPES_VERSION = "2.1.0"
-    PACER_REQ = ">= 1.0.0"
+    BLUEPRINTS_VERSION = "2.2.0"
+    PIPES_VERSION = "2.2.0"
+    PACER_REQ = ">= 1.1.2"
   end
 end

data/pom.xml

@@ -7,9 +7,9 @@
     <artifactId>pacer-neo4j</artifactId>
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-neo4j/version.rb -->
     <properties>
-      <gem.version>2.1.0</gem.version>
-      <blueprints.version>2.1.0</blueprints.version>
-      <pipes.version>2.1.0</pipes.version>
+      <blueprints.version>2.2.0</blueprints.version>
+      <gem.version>2.1.1</gem.version>
+      <pipes.version>2.2.0</pipes.version>
     </properties>
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-neo4j/version.rb -->
     <version>${gem.version}</version>

metadata

@@ -2,14 +2,14 @@
 name: pacer-neo4j
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 2.1.0
+  version: 2.1.1
 platform: java
 authors:
 - Darrick Wiebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-10-26 00:00:00.000000000 Z
+date: 2013-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pacer
@@ -17,13 +17,13 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.2
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.2
     none: false
   prerelease: false
   type: :runtime
@@ -43,18 +43,23 @@ files:
 - lib/pacer-neo4j/algo/block_cost_evaluator.rb
 - lib/pacer-neo4j/algo/block_estimate_evaluator.rb
 - lib/pacer-neo4j/algo/block_path_expander.rb
+- lib/pacer-neo4j/algo/cypher_transform.rb
 - lib/pacer-neo4j/algo/path_pipe.rb
 - lib/pacer-neo4j/algo/path_wrapper.rb
 - lib/pacer-neo4j/algo/traversal_branch_wrapper.rb
+- lib/pacer-neo4j/algo/wrapping.rb
+- lib/pacer-neo4j/blueprints_graph.rb
 - lib/pacer-neo4j/graph.rb
 - lib/pacer-neo4j/lucene_filter.rb
 - lib/pacer-neo4j/raw_vertex_wrapping_pipe.rb
 - lib/pacer-neo4j/rspec.rb
+- lib/pacer-neo4j/transaction_event_handler.rb
+- lib/pacer-neo4j/tx_data_wrapper.rb
 - lib/pacer-neo4j/version.rb
 - pacer-neo4j.gemspec
 - pom.xml
 - pom/standalone.xml
-- lib/pacer-neo4j-2.1.0-standalone.jar
+- lib/pacer-neo4j-2.1.1-standalone.jar
 homepage: http://neo4j.org
 licenses: []
 post_install_message: