neo4j-core 3.0.0.alpha.18 → 3.0.0.alpha.19

data/lib/neo4j-embedded/embedded_session.rb

@@ -23,6 +23,10 @@ module Neo4j::Embedded
       Neo4j::Session.register(self)
     end
 
+    def db_type
+      :embedded_db
+    end
+
     def inspect
       "#{self.class} db_location: '#{@db_location}', running: #{running?}"
     end
@@ -41,6 +45,16 @@ module Neo4j::Embedded
       Java::OrgNeo4jTest::ImpermanentGraphDatabase
     end
 
+    def begin_tx
+      if Neo4j::Transaction.current
+        # Handle nested transaction "placebo transaction"
+        Neo4j::Transaction.current.push_nested!
+      else
+        Neo4j::Embedded::EmbeddedTransaction.new(@graph_db.begin_tx)
+      end
+      Neo4j::Transaction.current
+    end
+
     def close
       super
       shutdown

data/lib/neo4j-embedded/embedded_session.rb~

@@ -0,0 +1,145 @@
+# Plugin
+
+Neo4j::Session.register_db(:embedded_db) do |*args|
+  Neo4j::Embedded::EmbeddedSession.new(*args)
+end
+
+
+module Neo4j::Embedded
+  class EmbeddedSession < Neo4j::Session
+
+    class Error < StandardError
+    end
+
+    attr_reader :graph_db, :db_location
+    extend Forwardable
+    extend Neo4j::Core::TxMethods
+    def_delegator :@graph_db, :begin_tx
+
+
+    def initialize(db_location, config={})
+      @db_location = db_location
+      @auto_commit = !!config[:auto_commit]
+      Neo4j::Session.register(self)
+      @query_builder = Neo4j::Core::QueryBuilder.new
+    end
+
+    def start
+      raise Error.new("Embedded Neo4j db is already running") if running?
+      puts "Start embedded Neo4j db at #{db_location}"
+      factory = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new
+      @graph_db = factory.newEmbeddedDatabase(db_location)
+      Neo4j::Session._notify_listeners(:session_available, self)
+    end
+
+    def factory_class
+      Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory
+      Java::OrgNeo4jTest::ImpermanentGraphDatabase
+    end
+
+    def close
+      super
+      shutdown
+    end
+
+    def shutdown
+      graph_db && graph_db.shutdown
+      @graph_db = nil
+    end
+
+    def running?
+      !!graph_db
+    end
+
+    def create_label(name)
+      EmbeddedLabel.new(self, name)
+    end
+
+    def load_node(neo_id)
+      _load_node(neo_id)
+    end
+    tx_methods :load_node
+
+    # Same as load but does not return the node as a wrapped Ruby object.
+    #
+    def _load_node(neo_id)
+      return nil if neo_id.nil?
+      @graph_db.get_node_by_id(neo_id.to_i)
+    rescue Java::OrgNeo4jGraphdb.NotFoundException
+      nil
+    end
+
+    def load_relationship(neo_id)
+      _load_relationship(neo_id)
+    end
+    tx_methods :load_relationship
+
+    def _load_relationship(neo_id)
+      return nil if neo_id.nil?
+      @graph_db.get_relationship_by_id(neo_id.to_i)
+    rescue Java::OrgNeo4jGraphdb.NotFoundException
+      nil
+    end
+
+    def query(*params)
+      query_hash = @query_builder.to_query_hash(params, :to_node)
+      cypher = @query_builder.to_cypher(query_hash)
+
+      result = _query(cypher, query_hash[:params])
+      if result.respond_to?(:error?) && result.error?
+        raise Neo4j::Session::CypherError.new(result.error_msg, result.error_code, result.error_status)
+      end
+
+      map_return_procs = @query_builder.to_map_return_procs(query_hash)
+      ResultWrapper.new(result, map_return_procs, cypher)
+    end
+
+    def find_all_nodes(label)
+      EmbeddedLabel.new(self, label).find_nodes
+    end
+
+    def find_nodes(label, key, value)
+      EmbeddedLabel.new(self, label).find_nodes(key,value)
+    end
+
+    # Performs a cypher query with given string.
+    # Remember that you should close the resource iterator.
+    # @param [String] q the cypher query as a String
+    # @return (see #query)
+    def _query(q, params={})
+      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
+      engine.execute(q, Neo4j::Core::HashWithIndifferentAccess.new(params))
+    rescue Exception => e
+        raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
+    end
+
+    def query_default_return(as)
+      " RETURN #{as}"
+    end
+
+    def _query_or_fail(q)
+      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
+      engine.execute(q)
+    end
+
+    def search_result_to_enumerable(result)
+      result.map {|column| column['n'].wrapper}
+    end
+
+    def create_node(properties = nil, labels=[])
+      if labels.empty?
+        _java_node = graph_db.create_node
+      else
+        labels = EmbeddedLabel.as_java(labels)
+        _java_node = graph_db.create_node(labels)
+      end
+      properties.each_pair { |k, v| _java_node[k]=v } if properties
+      _java_node
+    end
+    tx_methods :create_node
+
+  end
+
+
+
+end

data/lib/neo4j-embedded/embedded_transaction.rb

@@ -0,0 +1,35 @@
+module Neo4j::Embedded
+  class EmbeddedTransaction
+    attr_reader :root_tx
+    include Neo4j::Transaction::Instance
+
+    def initialize(root_tx)
+      @root_tx = root_tx
+      register_instance
+    end
+
+    def acquire_read_lock(entity)
+      @root_tx.acquire_read_lock(entity)
+    end
+
+    def acquire_write_lock(entity)
+      @root_tx.acquire_write_lock(entity)
+    end
+
+
+    def inspect
+      "EmbeddedTransaction [nested: #{@pushed_nested} failed?: #{failure?} active: #{Neo4j::Transaction.current == self}]"
+    end
+
+    def _delete_tx
+      @root_tx.failure
+      @root_tx.close
+    end
+
+    def _commit_tx
+      @root_tx.success
+      @root_tx.close
+    end
+
+  end
+end

data/lib/neo4j-embedded/property.rb

@@ -22,8 +22,8 @@ module Neo4j::Embedded::Property
   # * Values in the array must be of the same type.
   # * You can *not* delete or add one item in the array (e.g. person.phones.delete('123')) but instead you must create a new array instead.
   #
-  # @param [String, Symbol] key of the property to set
-  # @param [String,Fixnum,Float,true,false, Array] value to set
+  # @param [String, Symbol] k of the property to set
+  # @param [String,Fixnum,Float,true,false, Array] v to set
   def []=(k, v)
     to_java_property(k, v)
   end
@@ -61,6 +61,10 @@ module Neo4j::Embedded::Property
     get_id
   end
 
+  def refresh
+    # nothing is needed in the embedded db since we always asks the database
+  end
+
   private
 
   def to_ruby_property(key)

data/lib/neo4j-server/cypher_node.rb

@@ -7,9 +7,9 @@ module Neo4j::Server
       @session = session
 
       @id = if value.is_a?(Hash)
-        @response_hash = value
-        @props = @response_hash['data']
-        @response_hash['self'].match(/\d+$/)[0].to_i
+        hash = value['data']
+        @props = Hash[hash.map{ |k, v| [k.to_sym, v] }]
+        value['id'] # value['self'].match(/\d+$/)[0].to_i
       else
         value
       end
@@ -40,29 +40,37 @@ module Neo4j::Server
       if @props
         @props
       else
-        props = @session._query_or_fail("START n=node(#{neo_id}) RETURN n", true)['data']
-        props.keys.inject({}){|hash,key| hash[key.to_sym] = props[key]; hash}
+        hash = @session._query_entity_data("START n=node(#{neo_id}) RETURN n")
+        @props = Hash[hash['data'].map{ |k, v| [k.to_sym, v] }]
       end
     end
 
+    def refresh
+      @props = nil
+    end
+
     # (see Neo4j::Node#remove_property)
     def remove_property(key)
+      refresh
       @session._query_or_fail("START n=node(#{neo_id}) REMOVE n.`#{key}`")
     end
 
     # (see Neo4j::Node#set_property)
     def set_property(key,value)
+      refresh
       @session._query_or_fail("START n=node(#{neo_id}) SET n.`#{key}` = { value }", false, value: value)
       value
     end
 
     # (see Neo4j::Node#props=)
     def props=(properties)
+      refresh
       @session._query_or_fail("START n=node(#{neo_id}) SET n = { props }", false, {props: properties})
       properties
     end
 
     def remove_properties(properties)
+      refresh
       q = "START n=node(#{neo_id}) REMOVE " + properties.map do |k|
         "n.`#{k}`"
       end.join(', ')
@@ -71,6 +79,7 @@ module Neo4j::Server
 
     # (see Neo4j::Node#update_props)
     def update_props(properties)
+      refresh
       return if properties.empty?
 
       removed_keys = properties.keys.select{|k| properties[k].nil?}
@@ -86,7 +95,11 @@ module Neo4j::Server
 
     # (see Neo4j::Node#get_property)
     def get_property(key)
-      @session._query_or_fail("START n=node(#{neo_id}) RETURN n.`#{key}`", true)
+      if @props
+        @props[key.to_sym]
+      else
+        @session._query_or_fail("START n=node(#{neo_id}) RETURN n.`#{key}`", true)
+      end
     end
 
     # (see Neo4j::Node#labels)
@@ -134,7 +147,7 @@ module Neo4j::Server
       response = @session._query("START n=node(#{neo_id}) RETURN ID(n)")
       if (!response.error?)
         return true
-      elsif (response.error_status == 'EntityNotFoundException')
+      elsif (response.error_status =~ /EntityNotFound/)
         return false
       else
         response.raise_error

data/lib/neo4j-server/cypher_relationship.rb

@@ -15,8 +15,7 @@ module Neo4j::Server
         @props = @response_hash['data']
         @start_node_neo_id = @response_hash['start'].match(/\d+$/)[0].to_i
         @end_node_neo_id = @response_hash['end'].match(/\d+$/)[0].to_i
-
-        @response_hash['self'].match(/\d+$/)[0].to_i
+        @response_hash['id']
       else
         @rel_type = rel_type
 
@@ -44,6 +43,14 @@ module Neo4j::Server
       end
     end
 
+    def _start_node_id
+      @start_node_neo_id ||= get_node_id(:start)
+    end
+
+    def _end_node_id
+      @end_node_neo_id ||= get_node_id(:end)
+    end
+
     def _start_node
       load_resource
       id = resource_url_id(resource_url(:start))
@@ -56,6 +63,11 @@ module Neo4j::Server
       Neo4j::Node._load(id)
     end
 
+    def get_node_id(direction)
+      load_resource
+      resource_url_id(resource_url(direction))
+    end
+
     def get_property(key)
       id = neo_id
       @session._query_or_fail("START n=relationship(#{id}) RETURN n.`#{key}`", true)
@@ -76,8 +88,8 @@ module Neo4j::Server
       if @props
         @props
       else
-        props = @session._query_or_fail("START n=relationship(#{neo_id}) RETURN n", true)['data']
-        props.keys.inject({}){|hash,key| hash[key.to_sym] = props[key]; hash}
+        hash = @session._query_entity_data("START n=relationship(#{neo_id}) RETURN n")
+        @props = Hash[hash['data'].map{ |k, v| [k.to_sym, v] }]
       end
     end
 

data/lib/neo4j-server/cypher_response.rb

@@ -19,7 +19,6 @@ module Neo4j::Server
       def_delegator :@response, :error_msg
       def_delegator :@response, :error_status
       def_delegator :@response, :error_code
-      def_delegator :@response, :data
       def_delegator :@response, :columns
       def_delegator :@response, :struct
 
@@ -37,7 +36,7 @@ module Neo4j::Server
       end
 
       def each(&block)
-        data.each do |row|
+        @response.each_data_row do |row|
           yield(row.each_with_index.each_with_object(struct.new) do |(value, i), result|
             result[columns[i].to_sym] = value
           end)
@@ -53,23 +52,26 @@ module Neo4j::Server
       Enumerator.new do |yielder|
         self.to_struct_enumeration(cypher).each do |row|
           yielder << row.each_pair.each_with_object(@struct.new) do |(column, value), result|
-
-            result[column] = if value.is_a?(Hash)
-              if value['labels']
-                CypherNode.new(session, value).wrapper
-              elsif value['type']
-                CypherRelationship.new(session, value).wrapper
-              else
-                value
-              end
-            else
-              value
-            end
+            result[column] = map_row_value(value, session)
           end
         end
       end
     end
 
+    def map_row_value(value, session)
+      return value unless value.is_a?(Hash)
+
+      if value['labels']
+        add_entity_id(value)
+        CypherNode.new(session, value).wrapper
+      elsif value['type']
+        add_entity_id(value)
+        CypherRelationship.new(session, value).wrapper
+      else
+        value
+      end
+    end
+
     attr_reader :struct
     
     def initialize(response, uncommited = false)
@@ -78,14 +80,30 @@ module Neo4j::Server
     end
 
 
-    def first_data
+    def entity_data(id=nil)
+      if uncommited?
+        data = @data.first['row'].first
+        data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
+      else
+        data = @data[0][0]
+        data.is_a?(Hash) ? add_entity_id(data) : data
+      end
+    end
+
+    def first_data(id = nil)
       if uncommited?
-        @data.first['row'].first
+        data = @data.first['row'].first
+        #data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
       else
-        @data[0][0]
+        data = @data[0][0]
+        data.is_a?(Hash) ? add_entity_id(data) : data
       end
     end
 
+    def add_entity_id(data)
+      data.merge!({'id' => data['self'].match(/\d+$/)[0].to_i})
+    end
+
     def error?
       !!@error
     end
@@ -98,6 +116,14 @@ module Neo4j::Server
       raise "Response code #{response.code}, expected #{code} for #{response.request.path}, #{response.body}" unless response.code == code
     end
 
+    def each_data_row
+      if uncommited?
+        data.each{|r| yield r['row']}
+      else
+        data.each{|r| yield r}
+      end
+    end
+
     def set_data(data, columns)
       @data = data
       @columns = columns