neo4j-core 3.0.0.alpha.16 → 3.0.0.alpha.17

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "3.0.0.alpha.16"
+    VERSION = "3.0.0.alpha.17"
   end
 end

data/lib/neo4j-core/version.rb~

@@ -0,0 +1,5 @@
+module Neo4j
+  module Core
+    VERSION = "3.0.0.alpha.16"
+  end
+end

data/lib/neo4j-embedded/cypher_response.rb

@@ -14,10 +14,10 @@ module Neo4j::Embedded
     # @return the original result from the Neo4j Cypher Engine, once forward read only !
     attr_reader :source
 
-    def initialize(source, map_return_procs, query)
+    def initialize(source, query)
       @source = source
+      @struct = Struct.new(*source.columns.to_a.map(&:to_sym))
       @unread = true
-      @map_return_procs = map_return_procs
       @query = query
     end
 
@@ -31,59 +31,23 @@ module Neo4j::Embedded
 
     # @return [Array<Symbol>] the columns in the query result
     def columns
-      @source.columns.map { |x| x.to_sym }
+      @source.columns.map(&:to_sym)
     end
 
-    # for the Enumerable contract
-    def each(&block)
+    def each
       raise ResultsAlreadyConsumedException unless @unread
 
-      if (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
+      if block_given?
+        @source.each do |row|
+          yield(row.each_with_object(@struct.new) do |(column, value), result|
+            result[column.to_sym] = (value.respond_to?(:wrapper) ? value.wrapper : value)
+          end)
         end
       else
         Enumerator.new(self)
       end
     end
 
-
-    private
-
-    def each_no_mapping
-      @source.each do |row|
-        hash = {}
-        row.each do |key, value|
-          out[key.to_sym] = value
-        end
-        yield hash
-      end
-    end
-
-    def each_multi_column_mapping
-      @source.each do |row|
-        hash = {}
-        row.each do |key, value|
-          k = key.to_sym
-          proc = @map_return_procs[k]
-          hash[k] = proc ? proc.call(value) : value
-        end
-        yield hash
-      end
-    end
-
-    def each_single_column_mapping
-      @source.each do |row|
-        result = @map_return_procs.call(row.values.first)
-        yield result
-      end
-    end
-
   end
 end
 

data/lib/neo4j-embedded/embedded_session.rb

@@ -21,7 +21,6 @@ module Neo4j::Embedded
       @db_location = db_location
       @auto_commit = !!config[:auto_commit]
       Neo4j::Session.register(self)
-      @query_builder = Neo4j::Core::QueryBuilder.new
     end
 
     def inspect
@@ -34,6 +33,7 @@ module Neo4j::Embedded
       factory = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new
       @graph_db = factory.newEmbeddedDatabase(db_location)
       Neo4j::Session._notify_listeners(:session_available, self)
+      @engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
     end
 
     def factory_class
@@ -85,19 +85,17 @@ module Neo4j::Embedded
       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)
+    def query(*args)
+      if [[String], [String, String]].include?(args.map(&:class))
+        query, params = args[0,2]
+        Neo4j::Embedded::ResultWrapper.new(_query(query, params), query)
+      else
+        options = args[0] || {}
+        Neo4j::Core::Query.new(options.merge(session: self))
       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
@@ -111,10 +109,10 @@ module Neo4j::Embedded
     # @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))
+      @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')
+      raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
     end
 
     def query_default_return(as)
@@ -122,8 +120,8 @@ module Neo4j::Embedded
     end
 
     def _query_or_fail(q)
-      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-      engine.execute(q)
+      @engine ||= Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
+      @engine.execute(q)
     end
 
     def search_result_to_enumerable(result)
@@ -146,4 +144,4 @@ module Neo4j::Embedded
 
 
 
-end
+end

data/lib/neo4j-server/cypher_node.rb

@@ -3,9 +3,16 @@ module Neo4j::Server
     include Neo4j::Server::Resource
     include Neo4j::Core::CypherTranslator
 
-    def initialize(session, id)
+    def initialize(session, value)
       @session = session
-      @id = id
+
+      @id = if value.is_a?(Hash)
+        @response_hash = value
+        @props = @response_hash['data']
+        @response_hash['self'].match(/\d+$/)[0].to_i
+      else
+        value
+      end
     end
 
     def neo_id
@@ -30,8 +37,12 @@ module Neo4j::Server
 
     # (see Neo4j::Node#props)
     def props
-      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}
+      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}
+      end
     end
 
     # (see Neo4j::Node#remove_property)
@@ -187,4 +198,4 @@ module Neo4j::Server
     end
 
   end
-end
+end

data/lib/neo4j-server/cypher_relationship.rb

@@ -4,10 +4,24 @@ module Neo4j::Server
     include Neo4j::Server::Resource
     include Neo4j::Core::CypherTranslator
 
-    def initialize(session, id, rel_type)
+    attr_reader :start_node_neo_id, :end_node_neo_id
+
+    def initialize(session, value, rel_type = nil)
       @session = session
-      @id = id
-      @rel_type = rel_type
+
+      @id = if value.is_a?(Hash)
+        @response_hash = value
+        @rel_type = @response_hash['type']
+        @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
+      else
+        @rel_type = rel_type
+
+        value
+      end
     end
 
     def ==(o)
@@ -59,8 +73,12 @@ module Neo4j::Server
 
     # (see Neo4j::Relationship#props)
     def props
-      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}
+      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}
+      end
     end
 
     # (see Neo4j::Relationship#props=)
@@ -102,4 +120,4 @@ module Neo4j::Server
     end
 
   end
-end
+end

data/lib/neo4j-server/cypher_response.rb

@@ -21,10 +21,10 @@ module Neo4j::Server
       def_delegator :@response, :error_code
       def_delegator :@response, :data
       def_delegator :@response, :columns
+      def_delegator :@response, :struct
 
-      def initialize(response, map_return_procs, query)
+      def initialize(response, query)
         @response = response
-        @map_return_procs = map_return_procs
         @query = query
       end
 
@@ -36,48 +36,41 @@ module Neo4j::Server
         "Enumerable query: '#{@query}'"
       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
+      def each(&block)
         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
+          yield(row.each_with_index.each_with_object(struct.new) do |(value, i), result|
+            result[columns[i].to_sym] = value
+          end)
         end
       end
+    end
 
-      def each_single_column_mapping
-        data.each do |row|
-          result = @map_return_procs.call(row.first)
-          yield result
-        end
-      end
+    def to_struct_enumeration(cypher = '')
+      HashEnumeration.new(self, cypher)
+    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
+    def to_node_enumeration(cypher = '', session = Neo4j::Session.current)
+      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
+          end
         end
       end
     end
 
-    def to_hash_enumeration(map_return_procs={}, cypher='')
-      HashEnumeration.new(self, map_return_procs, cypher)
-    end
+    attr_reader :struct
 
     def initialize(response, uncommited = false)
       @response = response
@@ -108,6 +101,7 @@ module Neo4j::Server
     def set_data(data, columns)
       @data = data
       @columns = columns
+      @struct = columns.empty? ? Object.new : Struct.new(*columns.map(&:to_sym))
       self
     end
 
@@ -124,6 +118,12 @@ module Neo4j::Server
       raise ResponseError.new(@error_msg, @error_status, @error_code)
     end
 
+    def raise_cypher_error
+      raise "Tried to raise error without an error" unless @error
+      raise Neo4j::Session::CypherError.new(@error_msg, @error_code, @error_status)
+    end
+
+
     def self.create_with_no_tx(response)
       case response.code
         when 200

data/lib/neo4j-server/cypher_session.rb

@@ -35,7 +35,6 @@ 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
@@ -131,17 +130,14 @@ module Neo4j::Server
       search_result_to_enumerable_first_column(response)
     end
 
-    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)
+    def query(*args)
+      if [[String], [String, String]].include?(args.map(&:class))
+        query, params = args[0,2]
+        _query(query, params).to_node_enumeration(query)
+      else
+        options = args[0] || {}
+        Neo4j::Core::Query.new(options.merge(session: self))
       end
-
-      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)
@@ -207,4 +203,4 @@ module Neo4j::Server
       end
     end
   end
-end
+end

data/lib/neo4j/node.rb

@@ -180,25 +180,25 @@ module Neo4j
       end
 
       # Loads a node from the database with given id
-      def load(neo_id, session = Neo4j::Session.current)
+      def load(neo_id, session = Neo4j::Session.current!)
         node = _load(neo_id, session)
         node && node.wrapper
       end
 
       # Same as #load but does not try to return a wrapped node
       # @return [Neo4j::Node] an unwrapped node
-      def _load(neo_id, session = Neo4j::Session.current)
+      def _load(neo_id, session = Neo4j::Session.current!)
         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)
+      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)
+      def find_nodes(label, value=nil, session = Neo4j::Session.current!)
         session.find_nodes(label, value)
       end
     end

data/lib/neo4j/session.rb

@@ -46,71 +46,14 @@ module Neo4j
       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.
+    # Returns a Query object.  See Neo4j::Core::Query for more details, but basic usage looks like:
     #
-    # @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.*/})
+    # @example
+    #   session.query.match("(c:Car)<-[:OWNS]-(p:Person)").where(c: {vin: '234UAEB3425B'}).return(:p).first[:p]
     #
     # @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)
+    def query(options = {})
       raise 'not implemented, abstract'
     end
 
@@ -145,9 +88,14 @@ module Neo4j
         @@current_session
       end
 
+      def current!
+        raise "No session, please create a session first with Neo4j::Session.open(:server_db) or :embedded_db" unless current
+        current
+      end
+
       # @see Neo4j::Session#query
-      def query(*params)
-        current.query(*params)
+      def query(options = {})
+        current!.query(options)
       end
 
       def named(name)