neo4j-core 3.0.0.alpha.13 → 3.0.0.alpha.14

data/lib/neo4j-server/cypher_relationship.rb

@@ -25,8 +25,7 @@ module Neo4j::Server
     def load_resource
       id = neo_id
       unless @resource_data
-        r = @session._query_internal{ rel(id) }
-        @resource_data = r.first_data
+        @resource_data = @session._query_or_fail("START n=relationship(#{id}) RETURN n", true) # r.first_data
       end
     end
 
@@ -44,21 +43,17 @@ module Neo4j::Server
 
     def get_property(key)
       id = neo_id
-      r = @session._query_internal{rel(id)[key]}
-      expect_response_code(r.response, 200)
-      r.first_data
+      @session._query_or_fail("START n=relationship(#{id}) RETURN n.`#{key}`", true)
     end
 
     def set_property(key,value)
       id = neo_id
-      r = @session._query_internal{rel(id)[key]=value}
-      expect_response_code(r.response, 200)
+      @session._query_or_fail("START n=relationship(#{id}) SET n.`#{key}` = {value}", false, {value: value})
     end
 
     def remove_property(key)
       id = neo_id
-      r = @session._query_internal{rel(id)[key]=:NULL}
-      expect_response_code(r.response, 200)
+      @session._query_or_fail("START n=relationship(#{id}) REMOVE n.`#{key}`")
     end
 
     # (see Neo4j::Relationship#props)
@@ -86,12 +81,12 @@ module Neo4j::Server
 
     def del
       id = neo_id
-      @session._query_internal{rel(id).del}.raise_unless_response_code(200)
+      @session._query("START n=relationship(#{id}) DELETE n").raise_unless_response_code(200)
     end
 
     def exist?
       id = neo_id
-      response = @session._query_internal{rel(id)}
+      response = @session._query("START n=relationship(#{id}) RETURN n")
 
       if (!response.error?)
         return true

data/lib/neo4j-server/cypher_response.rb

@@ -22,23 +22,61 @@ module Neo4j::Server
       def_delegator :@response, :data
       def_delegator :@response, :columns
 
-      def initialize(response)
+      def initialize(response, map_return_procs, query)
         @response = response
+        @map_return_procs = map_return_procs
+        @query = query
       end
 
-      def each()
+      def to_s
+        @query
+      end
+
+      def inspect
+        "Enumerable query: '#{@query}'"
+      end
+
+      def each_no_mapping
         data.each do |row|
           hash = {}
           row.each_with_index do |row, i|
-            hash[columns[i].to_sym] = row
+            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
-      HashEnumeration.new(self)
+    def to_hash_enumeration(map_return_procs={}, cypher='')
+      HashEnumeration.new(self, map_return_procs, cypher)
     end
 
     def initialize(response, uncommited = false)

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

@@ -15,9 +15,8 @@ module Neo4j::Server
     # Opens a session to the database
     # @see Neo4j::Session#open
     #
-    # @param url - defaults to 'http://localhost:7474' if not given
-    # @params - see https://github.com/jnunemaker/httparty/blob/master/lib/httparty.rb for supported
-    # HTTParty options
+    # @param [String] endpoint_url - the url to the neo4j server, defaults to 'http://localhost:7474'
+    # @param [Hash] params - see https://github.com/jnunemaker/httparty/blob/master/lib/httparty.rb for supported HTTParty options
     def self.open(endpoint_url=nil, params = {})
       endpoint = Neo4jServerEndpoint.new(params)
       url = endpoint_url || 'http://localhost:7474'
@@ -36,10 +35,19 @@ module Neo4j::Server
       Neo4j::Session.register(self)
       initialize_resource(data_url)
       Neo4j::Session._notify_listeners(:session_available, self)
+      @query_builder = Neo4j::Core::QueryBuilder.new
     end
 
     def to_s
-      "CypherSession #{@resource_url}"
+      "#{self.class} url: '#{@resource_url}'"
+    end
+
+    def inspect
+      "#{to_s} version: '#{version}'"
+    end
+
+    def version
+      resource_data ? resource_data['neo4j_version'] : ''
     end
 
     def initialize_resource(data_url)
@@ -109,7 +117,7 @@ module Neo4j::Server
 
     def find_all_nodes(label_name)
       response = _query_or_fail("MATCH (n:`#{label_name}`) RETURN ID(n)")
-      search_result_to_enumerable(response)
+      search_result_to_enumerable_first_column(response)
     end
 
     def find_nodes(label_name, key, value)
@@ -120,20 +128,20 @@ module Neo4j::Server
         WHERE n.#{key} = #{value}
         RETURN ID(n)
       CYPHER
-      search_result_to_enumerable(response)
+      search_result_to_enumerable_first_column(response)
     end
 
-    def query(*params, &query_dsl)
-      result = super
+    def query(*params)
+      query_hash = @query_builder.to_query_hash(params, :id_to_node)
+      cypher = @query_builder.to_cypher(query_hash)
+
+      result = _query(cypher, query_hash[:params])
       if result.error?
         raise Neo4j::Session::CypherError.new(result.error_msg, result.error_code, result.error_status)
       end
-      result.to_hash_enumeration
-    end
 
-    # TODO remove this function and do not use cypher DSL internally
-    def _query_internal(*params, &query_dsl)
-      super_query(*params, &query_dsl)
+      map_return_procs = @query_builder.to_map_return_procs(query_hash)
+      result.to_hash_enumeration(map_return_procs, cypher)
     end
 
     def _query_or_fail(q, single_row = false, params=nil)
@@ -142,10 +150,6 @@ module Neo4j::Server
       single_row ? response.first_data : response
     end
 
-    def query_default_return
-      " RETURN ID(n)"
-    end
-
     def _query(q, params=nil)
       curr_tx = Neo4j::Transaction.current
       if (curr_tx)
@@ -158,9 +162,8 @@ module Neo4j::Server
       end
     end
 
-    def search_result_to_enumerable(response)
+    def search_result_to_enumerable_first_column(response)
       return [] unless response.data
-
       Enumerator.new do |yielder|
         response.data.each do |data|
           yielder << CypherNode.new(self, data[0]).wrapper
@@ -169,7 +172,39 @@ module Neo4j::Server
     end
 
 
+    def map_column(key, map, data)
+      case map[key]
+        when :node
+          CypherNode.new(self, data).wrapper
+        when :rel, :relationship
+          CypherRelationship.new(self, data)
+        else
+          data
+      end
+    end
+
 
+    def search_result_to_enumerable(response, ret, map)
+      return [] unless response.data
+
+      if (ret.size == 1)
+        Enumerator.new do |yielder|
+          response.data.each do |data|
+            yielder << map_column(key, map, data[0])
+          end
+        end
 
+      else
+        Enumerator.new do |yielder|
+          response.data.each do |data|
+            hash = {}
+            ret.each_with_index do |key, i|
+              hash[key] = map_column(key, map, data[i])
+            end
+            yielder << hash
+          end
+        end
+      end
+    end
   end
 end

data/lib/neo4j/label.rb

@@ -3,6 +3,7 @@ module Neo4j
   # See Neo4j::Node how to create and delete nodes
   # @see http://docs.neo4j.org/chunked/milestone/graphdb-neo4j-labels.html
   class Label
+    class InvalidQueryError < StandardError; end
 
     # @abstract
     def name
@@ -61,70 +62,25 @@ module Neo4j
     class << self
       include Neo4j::Core::CypherTranslator
 
+      # Returns a label of given name that can be used to specifying constraints
+      # @param [Symbol,String] name the name of the label
       def create(name, session = Neo4j::Session.current)
         session.create_label(name)
       end
 
-      def query(label_name, query, session = Neo4j::Session.current)
-        cypher = "MATCH (n:`#{label_name}`)"
-        cypher += condition_to_cypher(query) if query[:conditions] && !query[:conditions].empty?
-        cypher += session.query_default_return
-        cypher += order_to_cypher(query) if query[:order]
-
-        response = session._query_or_fail(cypher)
-        session.search_result_to_enumerable(response) # TODO make it work in Embedded and refactor
-      end
-
 
+      # @return [Enumerable<Neo4j::Node>] all nodes having given label. Nodes can be wrapped in your own model ruby classes.
       def find_all_nodes(label_name, session = Neo4j::Session.current)
         session.find_all_nodes(label_name)
       end
 
+      # @return [Enumerable<Neo4j::Node>] all nodes having given label and properties. Nodes can be wrapped in your own model ruby classes.
       def find_nodes(label_name, key, value, session = Neo4j::Session.current)
         session.find_nodes(label_name, key, value)
       end
 
-      private
-
-      def condition_to_cypher(query)
-        conditions = query[:conditions]
-        " WHERE " + conditions.keys.map do |k|
-          value = conditions[k]
-          if value.is_a? Regexp
-            pattern = (value.casefold? ? "(?i)" : "") + value.source
-            "n.#{k}=~#{escape_value(pattern.gsub(/\\/, '\\\\\\'))}"           
-          else 
-            "n.#{k}=#{escape_value(conditions[k])}"
-          end
-        end.join(" AND ")
-      end
-
-      def order_to_cypher(query)
-        cypher = " ORDER BY "
-        order = query[:order]
-
-        handleHash = Proc.new do |hash|
-          if (hash.is_a?(Hash))
-            k, v = hash.first
-            raise "only :asc or :desc allowed in order, got #{query.inspect}" unless [:asc, :desc].include?(v)
-            v.to_sym == :asc ? "n.`#{k}`" : "n.`#{k}` DESC"
-          else
-            "n.`#{hash}`" unless hash.is_a?(Hash)
-          end
-        end
-
-        case order
-          when Array
-            cypher += order.map(&handleHash).join(', ')
-          when Hash
-            cypher += handleHash.call(order)
-          else
-            cypher += "n.`#{order}`"
-        end
-
-        cypher
-      end
     end
+
   end
 
-end
+end