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

data/lib/neo4j-server/cypher_response.rb~

@@ -0,0 +1,155 @@
+module Neo4j::Server
+  class CypherResponse
+    attr_reader :data, :columns, :error_msg, :error_status, :error_code, :response
+
+    class ResponseError < StandardError
+      attr_reader :status, :code
+
+      def initialize(msg, status, code)
+        super(msg)
+        @status = status
+        @code = code
+      end
+    end
+
+
+    class HashEnumeration
+      include Enumerable
+      extend Forwardable
+      def_delegator :@response, :error_msg
+      def_delegator :@response, :error_status
+      def_delegator :@response, :error_code
+      def_delegator :@response, :data
+      def_delegator :@response, :columns
+
+      def initialize(response, map_return_procs, query)
+        @response = response
+        @map_return_procs = map_return_procs
+        @query = query
+      end
+
+      def to_s
+        @query
+      end
+
+puts "RELOADED"
+      def inspect
+        #"Enumerable query: '#{@query}' map_return: [#{@map_return_procs.keys.join(', ')}]"
+        "Enumerable query: '#{@query}' map_return: [#{@map_return_procs.keys.inspect}]"
+      end
+
+      def each_no_mapping
+        data.each do |row|
+          hash = {}
+          row.each_with_index do |row, i|
+            key = columns[i].to_sym
+            hash[key] = row
+          end
+          yield hash
+        end
+      end
+
+      def each_multi_column_mapping
+        data.each do |row|
+          hash = {}
+          row.each_with_index do |row, i|
+            key = columns[i].to_sym
+            proc = @map_return_procs[key]
+            hash[key] = proc ? proc.call(row) : row
+          end
+          yield hash
+        end
+      end
+
+      def each_single_column_mapping
+        data.each do |row|
+          result = @map_return_procs.call(row.first)
+          yield result
+        end
+      end
+
+      def each(&block)
+        case @map_return_procs
+          when NilClass then each_no_mapping &block
+          when Hash then each_multi_column_mapping &block
+          else each_single_column_mapping &block
+        end
+      end
+    end
+
+    def to_hash_enumeration(map_return_procs={}, cypher='')
+      HashEnumeration.new(self, map_return_procs, cypher)
+    end
+
+    def initialize(response, uncommited = false)
+      @response = response
+      @uncommited = uncommited
+    end
+
+
+    def first_data
+      if uncommited?
+        @data.first['row'].first
+      else
+        @data[0][0]
+      end
+    end
+
+    def error?
+      !!@error
+    end
+
+    def uncommited?
+      @uncommited
+    end
+
+    def raise_unless_response_code(code)
+      raise "Response code #{response.code}, expected #{code} for #{response.request.path}, #{response.body}" unless response.code == code
+    end
+
+    def set_data(data, columns)
+      @data = data
+      @columns = columns
+      self
+    end
+
+    def set_error(error_msg, error_status, error_core)
+      @error = true
+      @error_msg = error_msg
+      @error_status = error_status
+      @error_code = error_core
+      self
+    end
+
+    def raise_error
+      raise "Tried to raise error without an error" unless @error
+      raise ResponseError.new(@error_msg, @error_status, @error_code)
+    end
+
+    def self.create_with_no_tx(response)
+      case response.code
+        when 200
+          CypherResponse.new(response).set_data(response['data'], response['columns'])
+        when 400
+          CypherResponse.new(response).set_error(response['message'], response['exception'], response['fullname'])
+        else
+          raise "Unknown response code #{response.code} for #{response.request.path.to_s}"
+      end
+    end
+
+    def self.create_with_tx(response)
+      raise "Unknown response code #{response.code} for #{response.request.path.to_s}" unless response.code == 200
+
+      first_result = response['results'][0]
+      cr = CypherResponse.new(response, true)
+
+      if (response['errors'].empty?)
+        cr.set_data(first_result['data'], first_result['columns'])
+      else
+        first_error = response['errors'].first
+        cr.set_error(first_error['message'], first_error['status'], first_error['code'])
+      end
+      cr
+    end
+  end
+end

data/lib/neo4j-server/cypher_session.rb

@@ -37,6 +37,10 @@ module Neo4j::Server
       Neo4j::Session._notify_listeners(:session_available, self)
     end
 
+    def db_type
+      :server_db
+    end
+
     def to_s
       "#{self.class} url: '#{@resource_url}'"
     end
@@ -64,7 +68,13 @@ module Neo4j::Server
     end
 
     def begin_tx
-      Thread.current[:neo4j_curr_tx] = wrap_resource(self, 'transaction', CypherTransaction, nil, :post, @endpoint)
+      if Neo4j::Transaction.current
+        # Handle nested transaction "placebo transaction"
+        Neo4j::Transaction.current.push_nested!
+      else
+        wrap_resource(self, 'transaction', CypherTransaction, nil, :post, @endpoint)
+      end
+      Neo4j::Transaction.current
     end
 
     def create_node(props=nil, labels=[])
@@ -77,8 +87,9 @@ module Neo4j::Server
     def load_node(neo_id)
       cypher_response = _query("START n=node(#{neo_id}) RETURN n")
       if (!cypher_response.error?)
-        CypherNode.new(self, neo_id)
-      elsif (cypher_response.error_status == 'EntityNotFoundException')
+        result = cypher_response.entity_data(neo_id)
+        CypherNode.new(self, result)
+      elsif (cypher_response.error_status =~ /EntityNotFound/)
         return nil
       else
         cypher_response.raise_error
@@ -140,12 +151,24 @@ module Neo4j::Server
       end
     end
 
+    def _query_data(q)
+      r = _query_or_fail(q, true)
+      # the response is different if we have a transaction or not
+      Neo4j::Transaction.current ? r : r['data']
+    end
+
     def _query_or_fail(q, single_row = false, params=nil)
       response = _query(q, params)
       response.raise_error if response.error?
       single_row ? response.first_data : response
     end
 
+    def _query_entity_data(q, id=nil)
+      response = _query(q)
+      response.raise_error if response.error?
+      response.entity_data(id)
+    end
+
     def _query(q, params=nil)
       curr_tx = Neo4j::Transaction.current
       if (curr_tx)

data/lib/neo4j-server/cypher_transaction.rb

@@ -1,9 +1,10 @@
 module Neo4j::Server
   class CypherTransaction
-    attr_reader :commit_url, :exec_url
-
-    include Resource
+    include Neo4j::Transaction::Instance
     include Neo4j::Core::CypherTranslator
+    include Resource
+
+    attr_reader :commit_url, :exec_url
 
     class CypherError < StandardError
       attr_reader :code, :status
@@ -20,7 +21,7 @@ module Neo4j::Server
       @exec_url = response.headers['location']
       init_resource_data(response, url)
       expect_response_code(response,201)
-      Neo4j::Transaction.register(self)
+      register_instance
     end
 
     def _query(cypher_query, params=nil)
@@ -41,7 +42,10 @@ module Neo4j::Server
         end
       end
       response = @endpoint.post(@exec_url, headers: resource_headers, body: body.to_json)
+      _create_cypher_response(response)
+    end
 
+    def _create_cypher_response(response)
       first_result = response['results'][0]
       cr = CypherResponse.new(response, true)
 
@@ -54,29 +58,18 @@ module Neo4j::Server
       cr
     end
 
-    def success
-      # this is need in the Java API
-    end
 
-    def failure
-      @failure = true
-    end
 
-    def failure?
-      !!@failure
+    def _delete_tx
+      response = @endpoint.delete(@exec_url, headers: resource_headers)
+      expect_response_code(response,200)
+      response
     end
 
-    def finish
-      Neo4j::Transaction.unregister(self)
-      if failure?
-        response = @endpoint.delete(@exec_url, headers: resource_headers)
-      else
-        response = @endpoint.post(@commit_url, headers: resource_headers)
-      end
+    def _commit_tx
+      response = @endpoint.post(@commit_url, headers: resource_headers)
       expect_response_code(response,200)
       response
     end
-
-
   end
 end

data/lib/neo4j/node.rb

@@ -31,6 +31,11 @@ module Neo4j
       raise 'not implemented'
     end
 
+    # Refresh the properties by reading it from the database again next time an property value is requested.
+    def refresh
+      raise 'not implemented'
+    end
+
     # Updates the properties, keeps old properties
     # @param [Hash<Symbol, Object>] properties hash of properties that should be updated on the node
     def update_props(properties)
@@ -191,12 +196,6 @@ module Neo4j
         session.load_node(neo_id)
       end
 
-      # Checks if the given entity node or entity id (Neo4j::Node#neo_id) exists in the database.
-      # @return [true, false] if exist
-      def exist?(entity_or_entity_id, session = Neo4j::Session.current!)
-        session.node_exist?(neo_id)
-      end
-
       # Find the node with given label and value
       def find_nodes(label, value=nil, session = Neo4j::Session.current!)
         session.find_nodes(label, value)
@@ -205,7 +204,6 @@ module Neo4j
 
     def initialize
       raise "Can't instantiate abstract class" if abstract_class?
-      puts "Instantiated!"
     end
 
     private

data/lib/neo4j/relationship.rb

@@ -152,6 +152,11 @@ module Neo4j
       end
 
       def load(neo_id, session = Neo4j::Session.current)
+        rel = _load(neo_id, session)
+        rel && rel.wrapper
+      end
+
+      def _load(neo_id, session = Neo4j::Session.current)
         session.load_relationship(neo_id)
       end
 

data/lib/neo4j/session.rb

@@ -28,6 +28,11 @@ module Neo4j
       raise "not impl."
     end
 
+    # @return [:embedded_db | :server_db]
+    def db_type
+      raise "not impl."
+    end
+
     def auto_commit?
       true # TODO
     end
@@ -106,6 +111,17 @@ module Neo4j
         @@current_session = session
       end
 
+      # Registers a callback which will be called immediately if session is already available,
+      # or called when it later becomes available.
+      def on_session_available(&callback)
+        if (Neo4j::Session.current)
+          callback.call(Neo4j::Session.current)
+        end
+        add_listener do |event, data|
+          callback.call(data) if event == :session_available
+        end
+      end
+
       def add_listener(&listener)
         self._listeners << listener
       end

data/lib/neo4j/session.rb~

@@ -0,0 +1,202 @@
+module Neo4j
+  class Session
+
+    @@current_session = nil
+    @@all_sessions = {}
+    @@factories = {}
+
+    # @abstract
+    def close
+      self.class.unregister(self)
+    end
+
+    # Only for embedded database
+    # @abstract
+    def start
+      raise "not impl."
+    end
+
+    # Only for embedded database
+    # @abstract
+    def shutdown
+      raise "not impl."
+    end
+
+    # Only for embedded database
+    # @abstract
+    def running
+      raise "not impl."
+    end
+
+    def auto_commit?
+      true # TODO
+    end
+
+    # @abstract
+    def begin_tx
+      raise "not impl."
+    end
+
+    class CypherError < StandardError
+      attr_reader :error_msg, :error_status, :error_code
+      def initialize(error_msg, error_code, error_status)
+        super(error_msg)
+        @error_msg = error_msg
+        @error_status = error_status
+      end
+    end
+
+    # Executes a Cypher Query.
+    # Returns an enumerable of hash values where each hash corresponds to a row unless +return+ or +map_return+
+    # is not an array. The search result can be mapped to Neo4j::Node or Neo4j::Relationship is your own Ruby wrapper class
+    # by specifying a map_return parameter.
+    #
+    # @param [Hash, String] q the cypher query, as a pure string query or a hash which will generate a cypher string.
+    # @option q [Hash] :params cypher parameters
+    # @option q [Symbol,Hash] :label the label to match. You can specify several labels by using a hash of variable names and labels.
+    # @option q [Symbol] :conditions key and value of properties which the label nodes must match
+    # @option q [Hash] :conditions key and value of properties which the label nodes must match
+    # @option q [String, Array] :match the cypher match clause
+    # @option q [String, Array] :where the cypher where clause
+    # @option q [String, Array, Symbol] :return the cypher where clause
+    # @option q [String, Hash, Symbol] :map_return mapping of the returned values, e.g. :id_to_node, :id_to_rel, or :value
+    # @option q [Hash<Symbol, Proc>] :map_return_procs custom mapping functions of :map_return types
+    # @option q [String,Symbol,Array<Hash>] :order the order
+    # @option q [Fixnum] :limit enables the return of only subsets of the total result.
+    # @option q [Fixnum] :skip enables the return of only subsets of the total result.
+    # @return [Enumerable] the result, an enumerable of Neo4j::Node objects unless a pure cypher string is given or return/map_returns is specified, see examples.
+    # @raise CypherError if invalid cypher
+    # @example Cypher String and parameters
+    #   Neo4j::Session.query("START n=node({p}) RETURN ID(n)", params: {p: 42})
+    #
+    # @example label
+    #   # If there is no :return parameter it will try to return Neo4j::Node objects
+    #   # Default parameter is :n in the generated cypher
+    #   Neo4j::Session.query(label: :person) # => MATCH (n:`person`) RETURN ID(n) # or RETURN n for embedded
+    #
+    # @example to_s
+    #   # What Cypher is returned ? check with to_s
+    #   Neo4j::Session.query(label: :person).to_s # =>
+    #
+    # @example return
+    #   Neo4j::Session.query(label: :person, return: :age)  # returns age properties
+    #   Neo4j::Session.query(label: :person, return: [:name, :age]) # returns a hash of name and age properties
+    #   Neo4j::Session.query(label: :person, return: 'count(n) AS c')
+    #
+    # @example map_return - an Enumerable of names (String)
+    #   Neo4j::Session.query("START n=node(42) RETURN n.name", map_return: :value)
+    #
+    # @example map_return - Enumerable of an Hash with name property, Neo4j::Relationship and Neo4j::Node as values
+    #   Neo4j::Session.query("START n=node(42) MATCH n-[r]->[x] RETURN n.name as N, ID(r) as R, ID(x) as X",
+    #      map_return: {N: :value, R: :id_to_rel, X: :id_to_node})
+    #
+    # @example map_return, only for embedded_db, to_rel, and to_node allows direct mapping to Neo4j::Node and Neo4j::Relationship without ID(n)
+    #   Neo4j::Session.query("START n=node(42) MATCH n-[r]->[x] RETURN n.name as N, r, x", map_return: {N: :value, r: :to_rel, x: :to_node})
+    #
+    # @example map_return_procs, custom mapping function
+    #   Neo4j::Session.query(label: :person, map_return: :age_times_two, map_return_procs: {age_times_two: ->(row){(row[:age] || 0) * 2}})
+    #
+    # @example match
+    #   Neo4j::Session.query(label: :person, match: 'n--m')
+    #
+    # @example where
+    #   Neo4j::Session.query(label: :person, where: 'n.age > 40')
+    #   Neo4j::Session.query(label: :person, where: 'n.age > {age}', params: {age: 40})
+    #
+    # @example condition
+    #   Neo4j::Session.query(label: :person, conditions: {age: 42})
+    #   Neo4j::Session.query(label: :person, conditions: {name: /foo?bar.*/})
+    #
+    # @see http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html The Cypher Query Language Documentation
+    # @note Returns a read-once only forward iterable for the embedded database.
+    #
+    def query(q)
+      raise 'not implemented, abstract'
+    end
+
+    # Same as #query but does not accept an DSL and returns the raw result from the database.
+    # Notice, it might return different values depending on which database is used, embedded or server.
+    # @abstract
+    def _query(*params)
+      raise 'not implemented'
+    end
+
+    class << self
+      # Creates a new session to Neo4j
+      # @see also Neo4j::Server::CypherSession#open for :server_db params
+      # @param db_type the type of database, e.g. :embedded_db, or :server_db
+      def open(db_type=:server_db, *params)
+        register(create_session(db_type, params))
+      end
+
+      def open_named(db_type, name, default = nil, *params)
+        raise "Multiple sessions is currently only supported for Neo4j Server connections." unless db_type == :server_db
+        register(create_session(db_type, params), name, default)
+      end
+
+      def create_session(db_type, params = {})
+        unless (@@factories[db_type])
+          raise "Can't connect to database '#{db_type}', available #{@@factories.keys.join(',')}"
+        end
+        @@factories[db_type].call(*params)
+      end
+
+      def current
+        @@current_session
+      end
+
+      # @see Neo4j::Session#query
+      def query(*params)
+        current.query(*params)
+      end
+
+      def named(name)
+        @@all_sessions[name] || raise("No session named #{name}.")
+      end
+
+      def set_current(session)
+        @@current_session = session
+      end
+
+      def add_listener(&listener)
+        self._listeners << listener
+      end
+
+      def _listeners
+        @@listeners ||= []
+        @@listeners
+      end
+
+      def _notify_listeners(event, data)
+        _listeners.each {|li| li.call(event, data)}
+      end
+
+      def register(session, name = nil, default = nil)
+        if default == true
+          set_current(session)
+        elsif default.nil?
+          set_current(session) unless @@current_session
+        end
+        @@all_sessions[name] = session if name
+        @@current_session
+      end
+
+      def unregister(session)
+        @@current_session = nil if @@current_session == session
+      end
+
+      def all_sessions
+        @@all_sessions
+      end
+
+      def inspect
+         "Neo4j::Session available: #{@@factories && @@factories.keys}"
+      end
+
+      def register_db(db, &session_factory)
+        puts "replace factory for #{db}" if @@factories[db]
+        @@factories[db] = session_factory
+      end
+    end
+  end
+end