neo4j-core 4.0.7 → 5.0.0.rc.1

data/lib/neo4j-server/cypher_response.rb

@@ -36,54 +36,79 @@ module Neo4j
           "Enumerable query: '#{@query}'"
         end
 
-        def each(&block)
+        def each
           @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)
+            yield struct_rows(row)
+          end
+        end
+
+        def struct_rows(row)
+          struct.new.tap do |result|
+            row.each_with_index { |value, i| result[columns[i]] = value }
           end
         end
       end
 
-      def to_struct_enumeration(cypher = '')
+      EMPTY_STRING = ''
+      def to_struct_enumeration(cypher = EMPTY_STRING)
         HashEnumeration.new(self, cypher)
       end
 
-      def to_node_enumeration(cypher = '', session = Neo4j::Session.current)
+      def to_node_enumeration(cypher = EMPTY_STRING, session = Neo4j::Session.current)
         Enumerator.new do |yielder|
           @result_index = 0
           to_struct_enumeration(cypher).each do |row|
             @row_index = 0
-            yielder << row.each_pair.each_with_object(@struct.new) do |(column, value), result|
-              result[column] = map_row_value(value, session)
-              @row_index += 1
-            end
+            yielder << row_pair_in_struct(row, session)
             @result_index += 1
           end
         end
       end
 
+      def row_pair_in_struct(row, session)
+        @struct.new.tap do |result|
+          row.each_pair do |column, value|
+            result[column] = map_row_value(value, session)
+            @row_index += 1
+          end
+        end
+      end
+
       def map_row_value(value, session)
         if value.is_a?(Hash)
           hash_value_as_object(value, session)
         elsif value.is_a?(Array)
-          value.map { |v| map_row_value(v, session) }
+          value.map! { |v| map_row_value(v, session) }
         else
           value
         end
       end
 
       def hash_value_as_object(value, session)
-        return value unless value['labels'] || value['type'] || transaction_response?
+        data =  case
+                when transaction_response?
+                  add_transaction_entity_id
+                  mapped_rest_data
+                when value[:labels] || value[:type]
+                  add_entity_id(value)
+                  value
+                else
+                  return value
+                end
+        basic_obj = (node?(value) ? CypherNode : CypherRelationship).new(session, data)
+        unwrapped? ? basic_obj : basic_obj.wrapper
+      end
+
+      def unwrapped!
+        @_unwrapped_obj = true
+      end
+
+      def unwrapped?
+        !!@_unwrapped_obj
+      end
 
-        is_node, data =  if transaction_response?
-                           add_transaction_entity_id
-                           [!mapped_rest_data['start'], mapped_rest_data]
-                         elsif value['labels'] || value['type']
-                           add_entity_id(value)
-                           [value['labels'], value]
-                         end
-        (is_node ? CypherNode : CypherRelationship).new(session, data).wrapper
+      def node?(value)
+        transaction_response? ? !mapped_rest_data[:start] : value[:labels]
       end
 
       attr_reader :struct
@@ -95,17 +120,17 @@ module Neo4j
 
       def entity_data(id = nil)
         if @uncommited
-          data = @data.first['row'].first
-          data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
+          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)
+      def first_data
         if @uncommited
-          data = @data.first['row'].first
+          @data.first[:row].first
           # data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
         else
           data = @data[0][0]
@@ -114,45 +139,57 @@ module Neo4j
       end
 
       def add_entity_id(data)
-        data.merge!('id' => self.class.id_from_url(data['self']))
+        data[:id] = if data[:metadata] && data[:metadata][:id]
+                      data[:metadata][:id]
+                    else
+                      self.class.id_from_url(data[:self])
+                    end
+        data
       end
 
       def add_transaction_entity_id
-        mapped_rest_data.merge!('id' => mapped_rest_data['self'].split('/').last.to_i)
+        mapped_rest_data[:id] = mapped_rest_data[:self].split('/').last.to_i
+        mapped_rest_data
       end
 
       def error?
         !!@error
       end
 
+      RETRYABLE_ERROR_STATUSES = %w(DeadlockDetectedException AcquireLockTimeoutException ExternalResourceFailureException UnknownFailureException)
+      def retryable_error?
+        return unless error?
+        RETRYABLE_ERROR_STATUSES.include?(@error_status)
+      end
+
       def data?
-        !response.body['data'].nil?
+        !response.body[:data].nil?
       end
 
       def raise_unless_response_code(code)
-        fail "Response code #{response.status}, expected #{code} for #{response.headers['location']}, #{response.body}" unless response.status == code
+        fail "Response code #{response.status}, expected #{code} for #{response.headers[:location]}, #{response.body}" unless response.status == code
       end
 
       def each_data_row
         if @uncommited
-          data.each { |r| yield r['row'] }
+          data.each { |r| yield r[:row] }
         else
           data.each { |r| yield r }
         end
       end
 
-      def set_data(data, columns)
-        @data = data
-        @columns = columns
-        @struct = columns.empty? ? Object.new : Struct.new(*columns.map(&:to_sym))
+      def set_data(response)
+        @data = response[:data]
+        @columns = response[:columns]
+        @struct = @columns.empty? ? Object.new : Struct.new(*@columns.map(&:to_sym))
         self
       end
 
-      def set_error(error_msg, error_status, error_core)
+      def set_error(error)
         @error = true
-        @error_msg = error_msg
-        @error_status = error_status
-        @error_code = error_core
+        @error_msg = error[:message]
+        @error_status = error[:status] || error[:exception] || error[:code]
+        @error_code = error[:code] || error[:fullname]
         self
       end
 
@@ -170,9 +207,9 @@ module Neo4j
       def self.create_with_no_tx(response)
         case response.status
         when 200
-          CypherResponse.new(response).set_data(response.body['data'], response.body['columns'])
+          new(response).set_data(response.body)
         when 400
-          CypherResponse.new(response).set_error(response.body['message'], response.body['exception'], response.body['fullname'])
+          new(response).set_error(response.body)
         else
           fail "Unknown response code #{response.status} for #{response.env[:url]}"
         end
@@ -181,20 +218,18 @@ module Neo4j
       def self.create_with_tx(response)
         fail "Unknown response code #{response.status} for #{response.request_uri}" unless response.status == 200
 
-        first_result = response.body['results'][0]
-        cr = CypherResponse.new(response, true)
-
-        if response.body['errors'].empty?
-          cr.set_data(first_result['data'], first_result['columns'])
-        else
-          first_error = response.body['errors'].first
-          cr.set_error(first_error['message'], first_error['status'], first_error['code'])
+        new(response, true).tap do |cr|
+          body = response.body
+          if body[:errors].empty?
+            cr.set_data(body[:results].first)
+          else
+            cr.set_error(body[:errors].first)
+          end
         end
-        cr
       end
 
       def transaction_response?
-        response.respond_to?('body') && !response.body['commit'].nil?
+        response.respond_to?(:body) && !response.body[:commit].nil?
       end
 
       def rest_data
@@ -203,7 +238,8 @@ module Neo4j
       end
 
       def rest_data_with_id
-        rest_data.merge!('id' => mapped_rest_data['self'].split('/').last.to_i)
+        rest_data[:id] = mapped_rest_data[:self].split('/').last.to_i
+        rest_data
       end
 
       class << self
@@ -219,7 +255,7 @@ module Neo4j
       attr_reader :result_index
 
       def mapped_rest_data
-        response.body['results'][0]['data'][result_index]['rest'][row_index]
+        response.body[:results][0][:data][result_index][:rest][row_index]
       end
     end
   end

data/lib/neo4j-server/cypher_session.rb

@@ -1,8 +1,7 @@
 module Neo4j
   module Server
-    # Plugin
-    Neo4j::Session.register_db(:server_db) do |*url_opts|
-      Neo4j::Server::CypherSession.open(*url_opts)
+    Neo4j::Session.register_db(:server_db) do |endpoint_url, url_opts|
+      Neo4j::Server::CypherSession.open(endpoint_url, url_opts)
     end
 
     class CypherSession < Neo4j::Session
@@ -26,9 +25,10 @@ module Neo4j
         init_params = params[:initialize] && params.delete(:initialize)
         conn = Faraday.new(url, init_params) do |b|
           b.request :basic_auth, params[:basic_auth][:username], params[:basic_auth][:password] if params[:basic_auth]
-          b.request :json
+          b.request :multi_json
           # b.response :logger
-          b.response :json, content_type: 'application/json'
+
+          b.response :multi_json, symbolize_keys: true, content_type: 'application/json'
           # b.use Faraday::Response::RaiseError
           b.use Faraday::Adapter::NetHttpPersistent
           # b.adapter  Faraday.default_adapter
@@ -52,17 +52,14 @@ module Neo4j
       end
 
       def self.establish_session(root_data, connection)
-        data_url = root_data['data']
+        data_url = root_data[:data]
         data_url << '/' unless data_url.nil? || data_url.end_with?('/')
         CypherSession.new(data_url, connection)
       end
 
       def self.extract_basic_auth(url, params)
         return unless url && URI(url).userinfo
-        params[:basic_auth] = {
-          username: URI(url).user,
-          password: URI(url).password
-        }
+        params[:basic_auth] = {username: URI(url).user, password: URI(url).password}
       end
 
       private_class_method :extract_basic_auth
@@ -80,12 +77,12 @@ module Neo4j
       end
 
       def version
-        resource_data ? resource_data['neo4j_version'] : ''
+        resource_data ? resource_data[:neo4j_version] : ''
       end
 
       def initialize_resource(data_url)
         response = @connection.get(data_url)
-        expect_response_code(response, 200)
+        expect_response_code!(response, 200)
         data_resource = response.body
         fail "No data_resource for #{response.body}" unless data_resource
         # store the resource data
@@ -98,43 +95,27 @@ module Neo4j
       end
 
       def begin_tx
-        if Neo4j::Transaction.current
-          # Handle nested transaction "placebo transaction"
-          Neo4j::Transaction.current.push_nested!
-        else
-          wrap_resource(@connection)
-        end
+        Neo4j::Transaction.current ? Neo4j::Transaction.current.push_nested! : wrap_resource(@connection)
         Neo4j::Transaction.current
       end
 
       def create_node(props = nil, labels = [])
-        id = _query_or_fail(cypher_string(labels, props), true, cypher_prop_list(props))
-        value = props.nil? ? id : {'id' => id, 'metadata' => {'labels' => labels}, 'data' => props}
+        id = _query_or_fail(cypher_string(labels, props), true, cypher_prop_list!(props))
+        value = props.nil? ? id : {id: id, metadata: {labels: labels}, data: props}
         CypherNode.new(self, value)
       end
 
       def load_node(neo_id)
-        load_entity(CypherNode, _query("MATCH (n) WHERE ID(n) = #{neo_id} RETURN n"))
+        query.unwrapped.match(:n).where(n: {neo_id: neo_id}).pluck(:n).first
       end
 
       def load_relationship(neo_id)
-        load_entity(CypherRelationship, _query("MATCH (n)-[r]-() WHERE ID(r) = #{neo_id} RETURN r"))
-      end
-
-      def load_entity(clazz, cypher_response)
-        return nil if cypher_response.data.nil? || cypher_response.data[0].nil?
-        data  = if cypher_response.transaction_response?
-                  cypher_response.rest_data_with_id
-                else
-                  cypher_response.first_data
-                end
-
-        if cypher_response.error?
-          cypher_response.raise_error
-        elsif cypher_response.error_msg =~ /not found/  # Ugly that the Neo4j API gives us this error message
-          return nil
+        query.unwrapped.optional_match('(n)-[r]-()').where(r: {neo_id: neo_id}).pluck(:r).first
+      rescue Neo4j::Session::CypherError => cypher_error
+        if cypher_error.message.match(/not found$/)
+          nil
         else
-          clazz.new(self, data)
+          raise cypher_error
         end
       end
 
@@ -143,17 +124,17 @@ module Neo4j
       end
 
       def uniqueness_constraints(label)
-        schema_properties("#{@resource_url}schema/constraint/#{label}/uniqueness")
+        schema_properties("/db/data/schema/constraint/#{label}/uniqueness")
       end
 
       def indexes(label)
-        schema_properties("#{@resource_url}schema/index/#{label}")
+        schema_properties("/db/data/schema/index/#{label}")
       end
 
       def schema_properties(query_string)
         response = @connection.get(query_string)
-        expect_response_code(response, 200)
-        {property_keys: response.body.map { |row| row['property_keys'].map(&:to_sym) }}
+        expect_response_code!(response, 200)
+        {property_keys: response.body.map! { |row| row[:property_keys].map(&:to_sym) }}
       end
 
       def find_all_nodes(label_name)
@@ -163,17 +144,15 @@ module Neo4j
       def find_nodes(label_name, key, value)
         value = "'#{value}'" if value.is_a? String
 
-        response = _query_or_fail <<-CYPHER
-          MATCH (n:`#{label_name}`)
-          WHERE n.#{key} = #{value}
-          RETURN ID(n)
-        CYPHER
+        response = _query_or_fail("MATCH (n:`#{label_name}`) WHERE n.#{key} = #{value} RETURN ID(n)")
         search_result_to_enumerable_first_column(response)
       end
 
       def query(*args)
         if [[String], [String, Hash]].include?(args.map(&:class))
-          query, params = args[0, 2]
+          query = args[0]
+          params = args[1]
+
           response = _query(query, params)
           response.raise_error if response.error?
           response.to_node_enumeration(query)
@@ -183,77 +162,85 @@ module Neo4j
         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']
+      def _query_data(query)
+        r = _query_or_fail(query, true)
+        Neo4j::Transaction.current ? r : r[:data]
       end
 
-      def _query_or_fail(q, single_row = false, params = {})
-        if q.is_a?(::Neo4j::Core::Query)
-          cypher = q.to_cypher
-          params = q.send(:merge_params).merge(params)
-          q = cypher
+      DEFAULT_RETRY_COUNT = ENV['NEO4J_RETRY_COUNT'].nil? ? 10 : ENV['NEO4J_RETRY_COUNT'].to_i
+
+      def _query_or_fail(query, single_row = false, params = {}, retry_count = DEFAULT_RETRY_COUNT)
+        query, params = query_and_params(query, params)
+
+        response = _query(query, params)
+        if response.error?
+          _retry_or_raise(query, params, single_row, retry_count, response)
+        else
+          single_row ? response.first_data : response
         end
+      end
 
-        response = _query(q, params)
-        response.raise_error if response.error?
-        single_row ? response.first_data : response
+      def query_and_params(query_or_query_string, params)
+        if query_or_query_string.is_a?(::Neo4j::Core::Query)
+          cypher = query_or_query_string.to_cypher
+          [cypher, query_or_query_string.send(:merge_params).merge(params)]
+        else
+          [query_or_query_string, params]
+        end
       end
 
-      def _query_entity_data(q, id = nil, params = nil)
-        response = _query(q, params)
-        response.raise_error if response.error?
-        response.entity_data(id)
+      def _retry_or_raise(query, params, single_row, retry_count, response)
+        response.raise_error unless response.retryable_error?
+        retry_count > 0 ? _query_or_fail(query, single_row, params, retry_count - 1) : response.raise_error
       end
 
-      def _query(q, params = nil)
-        # puts "q #{q}"
+      def _query_entity_data(query, id = nil, params = {})
+        _query_response(query, params).entity_data(id)
+      end
+
+      def _query_response(query, params = {})
+        _query(query, params).tap do |response|
+          response.raise_error if response.error?
+        end
+      end
+
+      def _query(query, params = {})
+        query, params = query_and_params(query, params)
+
         curr_tx = Neo4j::Transaction.current
         if curr_tx
-          curr_tx._query(q, params)
+          curr_tx._query(query, params)
         else
-          url = resource_url('cypher')
-          q = params.nil? ? {'query' => q} : {'query' => q, 'params' => params}
-          response = @connection.post(url, q)
+          url = resource_url(:cypher)
+          query = params.nil? ? {'query' => query} : {'query' => query, 'params' => params}
+          response = @connection.post(url, query)
           CypherResponse.create_with_no_tx(response)
         end
       end
 
       def search_result_to_enumerable_first_column(response)
         return [] unless response.data
-        if Neo4j::Transaction.current
-          search_result_to_enumerable_first_column_with_tx(response)
-        else
-          search_result_to_enumerable_first_column_without_tx(response)
-        end
-      end
 
-      def search_result_to_enumerable_first_column_with_tx(response)
         Enumerator.new do |yielder|
           response.data.each do |data|
-            data['row'].each do |id|
-              yielder << CypherNode.new(self, id).wrapper
+            if Neo4j::Transaction.current
+              data[:row].each do |id|
+                yielder << CypherNode.new(self, id).wrapper
+              end
+            else
+              yielder << CypherNode.new(self, data[0]).wrapper
             end
           end
         end
       end
 
-      def search_result_to_enumerable_first_column_without_tx(response)
-        Enumerator.new do |yielder|
-          response.data.each do |data|
-            yielder << CypherNode.new(self, data[0]).wrapper
-          end
-        end
-      end
-
-      def map_column(key, map, data)
-        if map[key] == :node
-          CypherNode.new(self, data).wrapper
-        elsif map[key] == :rel || map[:key] || :relationship
-          CypherRelationship.new(self, data)
-        else
-          data
+      EMPTY = ''
+      def self.log_with
+        clear, yellow, cyan = %W(\e[0m \e[33m \e[36m)
+        ActiveSupport::Notifications.subscribe('neo4j.cypher_query') do |_, start, finish, _id, payload|
+          ms = (finish - start) * 1000
+          params_string = (payload[:params].size > 0 ? "| #{payload[:params].inspect}" : EMPTY)
+          yield(" #{cyan}#{payload[:context]}#{clear} #{yellow}#{ms.round}ms#{clear} #{payload[:cypher]} #{params_string}")
         end
       end
     end

data/lib/neo4j-server/cypher_transaction.rb

@@ -2,9 +2,9 @@ module Neo4j
   module Server
     # The CypherTransaction object lifecycle is as follows:
     # * It is initialized with the transactional endpoint URL and the connection object to use for communication. It does not communicate with the server to create this.
-    # * The first query within the transaction sets the commit and execution addresses, :commit_url and :exec_url.
+    # * The first query within the transaction sets the commit and execution addresses, :commit_url and :query_url.
     # * At any time, `failure` can be called to mark a transaction failed and trigger a rollback upon closure.
-    # * `close` is called to end the transaction. It calls `_commit_tx` or `_delete_tx`.
+    # * `close` is called to end the transaction. It calls `commit` or `delete`.
     #
     # If a transaction is created and then closed without performing any queries, an OpenStruct is returned that behaves like a successfully closed query.
     class CypherTransaction
@@ -12,7 +12,7 @@ module Neo4j
       include Neo4j::Core::CypherTranslator
       include Resource
 
-      attr_reader :commit_url, :exec_url, :base_url, :connection
+      attr_reader :commit_url, :query_url, :base_url, :connection
 
       def initialize(url, session_connection)
         @base_url = url
@@ -26,49 +26,58 @@ module Neo4j
         statement = {statement: cypher_query, parameters: params, resultDataContents: ROW_REST}
         body = {statements: [statement]}
 
-        response = exec_url && commit_url ? connection.post(exec_url, body) : register_urls(body)
-        _create_cypher_response(response)
+        response = @query_url ? query(body) : start(body)
+
+        create_cypher_response(response)
       end
 
-      def _delete_tx
-        _tx_query(:delete, exec_url, headers: resource_headers)
+      def start(body)
+        request(:post, @base_url, 201, body).tap do |response|
+          @commit_url = response.body[:commit]
+          @query_url = response.headers[:Location]
+
+          fail "NO ENDPOINT URL #{connection} : HEAD: #{response.headers.inspect}" if !@query_url || @query_url.empty?
+
+          init_resource_data(response.body, @base_url)
+        end
       end
 
-      def _commit_tx
-        _tx_query(:post, commit_url, nil)
+      def query(body)
+        request(:post, @query_url, 200, body)
       end
 
-      private
+      def delete
+        return empty_response if !@commit_url || expired?
 
-      def _tx_query(action, endpoint, headers = {})
-        return empty_response if !commit_url || expired?
-        response = connection.send(action, endpoint, headers)
-        expect_response_code(response, 200)
-        response
+        request(:delete, @query_url, 200, nil, resource_headers)
       end
 
-      def register_urls(body)
-        response = connection.post(base_url, body)
-        @commit_url = response.body['commit']
-        @exec_url = response.headers['Location']
-        fail "NO ENDPOINT URL #{connection} : HEAD: #{response.headers.inspect}" if !exec_url || exec_url.empty?
-        init_resource_data(response.body, base_url)
-        expect_response_code(response, 201)
-        response
+      def commit
+        return empty_response if !@commit_url || expired?
+
+        request(:post, @commit_url, 200, nil, resource_headers)
+      end
+
+      private
+
+      def request(action, endpoint_url, expected_code = 200, body = nil, headers = {})
+        connection.send(action, endpoint_url, body, headers).tap do |response|
+          expect_response_code!(response, expected_code)
+        end
       end
 
-      def _create_cypher_response(response)
-        first_result = response.body['results'][0]
+      def create_cypher_response(response)
+        first_result = response.body[:results][0]
 
-        cr = CypherResponse.new(response, true)
-        if response.body['errors'].empty?
-          cr.set_data(first_result['data'], first_result['columns'])
-        else
-          first_error = response.body['errors'].first
-          expired if first_error['message'].match(/Unrecognized transaction id/)
-          cr.set_error(first_error['message'], first_error['code'], first_error['code'])
+        CypherResponse.new(response, true).tap do |cypher_response|
+          if response.body[:errors].empty?
+            cypher_response.set_data(first_result)
+          else
+            first_error = response.body[:errors].first
+            mark_expired if first_error[:message].match(/Unrecognized transaction id/)
+            cypher_response.set_error(first_error)
+          end
         end
-        cr
       end
 
       def empty_response