neo4j 3.0.0.rc.3 → 3.0.0.rc.4

data/lib/neo4j/active_rel/query.rb

@@ -3,7 +3,6 @@ module Neo4j::ActiveRel
     extend ActiveSupport::Concern
 
     module ClassMethods
-      include Enumerable
 
       # Returns the object with the specified neo4j id.
       # @param [String,Fixnum] id of node to find
@@ -13,54 +12,77 @@ module Neo4j::ActiveRel
         find_by_id(id, session)
       end
 
+      # Loads the relationship using its neo_id.
       def find_by_id(key, session = Neo4j::Session.current!)
         Neo4j::Relationship.load(key.to_i, session)
       end
 
-      # TODO make this not awful
+      # Performs a very basic match on the relationship.
+      # This is not executed lazily, it will immediately return matching objects.
+      # To use a string, prefix the property with "r1"
+      # @example Match with a string
+      #   MyRelClass.where('r1.grade > r1')
       def where(args={})
-        @query = if self._from_class == :any
-          Neo4j::Session.query("MATCH n1-[r1:`#{self._type}`]->(#{cypher_node_string(:inbound)}) WHERE #{where_string(args)} RETURN r1")
-        else
-          self._from_class.query_as(:n1).match("(#{cypher_node_string(:outbound)})-[r1:`#{self._type}`]->(#{cypher_node_string(:inbound)})").where(Hash["r1" => args])
-        end
-        return self
+        Neo4j::Session.query.match("#{cypher_string(:outbound)}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}").where(where_string(args)).pluck(:r1)
       end
 
-      def each
-        if self._from_class == :any
-          @query.map(&:r1)
-        else
-          @query.pluck(:r1)
-        end.each {|r| yield r }
+      # Performs a basic match on the relationship, returning all results.
+      # This is not executed lazily, it will immediately return matching objects.
+      def all
+        all_query.pluck(:r1)
       end
 
       def first
-        if self._from_class == :any
-          @query.map(&:r1)
-        else
-          @query.pluck(:r1)
-        end.first
+        all_query.limit(1).order("ID(r1)").pluck(:r1).first
+      end
+
+      def last
+        all_query.limit(1).order("ID(r1) DESC").pluck(:r1).first
+      end
+
+      private
+
+      def all_query
+        Neo4j::Session.query.match("#{cypher_string}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
       end
 
-      def cypher_node_string(dir)
+      def cypher_string(dir = :outbound)
         case dir
         when :outbound
-          node_identifier, dir_class = 'n1', self._from_class
+          identifier = '(n1'
+          identifier + (_from_class == :any ? ')' : cypher_label(:outbound))
         when :inbound
-          node_identifier, dir_class = 'n2', self._to_class
-        end
-        dir_class == :any ? node_identifier : "#{node_identifier}:`#{dir_class.name}`"
+          identifier = '(n2'
+          identifier + (_to_class == :any ? ')' : cypher_label(:inbound))
+        end 
       end
 
-      private
+      def cypher_label(dir = :outbound)
+        target_class = dir == :outbound ? as_constant(_from_class) : as_constant(_to_class)
+        ":`#{target_class.mapped_label_name}`)"
+      end
+
+      def as_constant(given_class)
+        case
+        when given_class.is_a?(String)
+          given_class.constantize
+        when given_class.is_a?(Symbol)
+          given_class.to_s.constantize
+        else
+          given_class
+        end
+      end
 
       def where_string(args)
-        args.map do |k, v|
-          v.is_a?(Integer) ? "r1.#{k} = #{v}" : "r1.#{k} = '#{v}'"
-        end.join(', ')
+        if args.is_a?(Hash)
+          args.map do |k, v|
+            v.is_a?(Integer) ? "r1.#{k} = #{v}" : "r1.#{k} = '#{v}'"
+          end.join(', ')
+        else 
+          args
+        end
       end
 
     end
   end
-end
+end

data/lib/neo4j/active_rel/related_node.rb

@@ -2,14 +2,10 @@ module Neo4j::ActiveRel
   # A container for ActiveRel's :inbound and :outbound methods. It provides lazy loading of nodes.
   class RelatedNode
 
-    class InvalidParameterError < StandardError
-      def message
-        'RelatedNode must be initialized with either a node ID or node'
-      end
-    end
+    class InvalidParameterError < StandardError; end
 
     def initialize(node = nil)
-      @node = valid_node_param?(node) ? node : (raise InvalidParameterError.new(self))
+      @node = valid_node_param?(node) ? node : (raise InvalidParameterError, 'RelatedNode must be initialized with either a node ID or node' )
     end
 
     def == (obj)

data/lib/neo4j/migration.rb

@@ -0,0 +1,185 @@
+module Neo4j
+  class Migration
+    class AddIdProperty < Neo4j::Migration
+      attr_reader :models_filename
+
+      def initialize
+        @models_filename = File.join(Rails.root.join('db', 'neo4j-migrate'), 'add_id_property.yml')
+      end
+
+      def migrate
+        models = ActiveSupport::HashWithIndifferentAccess.new(YAML.load_file(models_filename))[:models]
+        puts "This task will add an ID Property every node in the given file."
+        puts "It may take a significant amount of time, please be patient."
+        models.each do |model|
+          puts
+          puts
+          puts "Adding IDs to #{model}"
+          add_ids_to model.constantize
+        end
+      end
+
+      def setup
+        FileUtils.mkdir_p("db/neo4j-migrate")
+        unless File.file?(models_filename)
+          File.open(models_filename, 'w') do |file|
+            file.write("# Provide models to which IDs should be added.\n# It will only modify nodes that do not have IDs. There is no danger of overwriting data.\n# models: [Student,Lesson,Teacher,Exam]\nmodels: []")
+          end
+        end
+      end
+
+      private
+
+      def add_ids_to(model)
+        require 'benchmark'
+
+        max_per_batch = (ENV['MAX_PER_BATCH'] || default_max_per_batch).to_i
+
+        label = model.mapped_label_name
+        property = model.primary_key
+        nodes_left = 1
+        last_time_taken = nil
+
+        until nodes_left == 0
+          nodes_left = Neo4j::Session.query.match(n: label).where("NOT has(n.#{property})").return("COUNT(n) AS ids").first.ids
+
+          time_per_node = last_time_taken / max_per_batch if last_time_taken
+          print "Running first batch...\r"
+          if time_per_node
+            eta_seconds = (nodes_left * time_per_node).round
+            print "#{nodes_left} nodes left.  Last batch: #{(time_per_node * 1000.0).round(1)}ms / node (ETA: #{eta_seconds / 60} minutes)\r"
+          end
+
+          return if nodes_left == 0
+          to_set = [nodes_left, max_per_batch].min
+
+          new_ids = to_set.times.map { new_id_for(model) }
+          begin
+            last_time_taken = id_batch_set(label, property, new_ids, to_set)
+          rescue Neo4j::Server::CypherResponse::ResponseError, Faraday::TimeoutError
+            new_max_per_batch = (max_per_batch * 0.8).round
+            puts "Error querying #{max_per_batch} nodes.  Trying #{new_max_per_batch}"
+            max_per_batch = new_max_per_batch
+          end
+        end
+      end
+
+      def id_batch_set(label, property, new_ids, to_set)
+        Benchmark.realtime do
+          Neo4j::Transaction.run do
+            Neo4j::Session.query("MATCH (n:`#{label}`) WHERE NOT has(n.#{property})
+              with COLLECT(n) as nodes, #{new_ids} as ids
+              FOREACH(i in range(0,#{to_set - 1})|
+                FOREACH(node in [nodes[i]]|
+                  SET node.#{property} = ids[i]))
+              RETURN distinct(true)
+              LIMIT #{to_set}")
+          end
+        end
+      end
+
+      def default_max_per_batch
+        900
+      end
+
+      def new_id_for(model)
+        if model.id_property_info[:type][:auto]
+          SecureRandom::uuid
+        else
+          model.new.send(model.id_property_info[:type][:on])
+        end
+      end
+    end
+
+    class AddClassnames < Neo4j::Migration
+      attr_reader :classnames_filename, :classnames_filepath
+
+      def initialize
+        @classnames_filename = 'add_classnames.yml'
+        @classnames_filepath = File.join(Rails.root.join('db', 'neo4j-migrate'), classnames_filename)
+      end
+
+      def migrate
+        puts "Adding classnames. This make take some time."
+        execute(true)
+      end
+
+      def test
+        puts "TESTING! No queries will be executed."
+        execute(false)
+      end
+
+      def setup
+        puts "Creating file #{classnames_filepath}. Please use this as the migration guide."
+        FileUtils.mkdir_p("db/neo4j-migrate")
+        unless File.file?(@classnames_filepath)
+          source = File.join(File.dirname(__FILE__), "..", "..", "config", "neo4j", classnames_filename)
+          FileUtils.copy_file(source, classnames_filepath)
+        end
+      end
+
+      private
+
+      def execute(migrate = false)
+        file_init
+        map = []
+        map.push :nodes         if @model_map[:nodes]
+        map.push :relationships if @model_map[:relationships]
+        map.each do |type|
+          @model_map[type].each do |action, labels|
+            do_classnames(action, labels, type, migrate)
+          end
+        end
+      end
+
+      def do_classnames(action, labels, type, migrate = false)
+        method = type == :nodes ? :node_cypher : :rel_cypher
+        labels.each do |label|
+          puts cypher = self.send(method, label, action)
+          execute_cypher(cypher) if migrate
+        end
+      end
+
+      def file_init
+        @model_map = ActiveSupport::HashWithIndifferentAccess.new(YAML.load_file(classnames_filepath)) 
+      end
+
+      def node_cypher(label, action)
+        where, phrase_start = action_variables(action, 'n')
+        puts "#{phrase_start} _classname '#{label}' on nodes with matching label:"
+        "MATCH (n:`#{label}`) #{where} SET n._classname = '#{label}' RETURN COUNT(n) as modified"
+      end
+
+      def rel_cypher(hash, action)
+        label = hash[0]
+        value = hash[1]
+        from = value[:from]
+        raise "All relationships require a 'type'" unless value[:type]
+
+        from_cypher = from ? "(from:`#{from}`)" : "(from)"
+        to = value[:to]
+        to_cypher = to ? "(to:`#{to}`)" : "(to)"
+        type = "[r:`#{value[:type]}`]"
+        where, phrase_start = action_variables(action, 'r')
+        puts "#{phrase_start} _classname '#{label}' where type is '#{value[:type]}' using cypher:"
+        "MATCH #{from_cypher}-#{type}->#{to_cypher} #{where} SET r._classname = '#{label}' return COUNT(r) as modified"
+      end
+
+      def execute_cypher(query_string)
+        puts "Modified #{Neo4j::Session.query(query_string).first.modified} records"
+        puts ""
+      end
+
+      def action_variables(action, identifier)
+        case action
+        when 'overwrite'
+          ['', 'Overwriting']
+        when 'add'
+          ["WHERE NOT HAS(#{identifier}._classname)", 'Adding']
+        else
+          raise "Invalid action #{action} specified"
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/paginated.rb

@@ -10,10 +10,11 @@ module Neo4j
     def self.create_from(source, page, per_page)
       #partial = source.drop((page-1) * per_page).first(per_page)
       partial = source.skip(page-1).limit(per_page)
-      Paginated.new(partial, source.instance_variable_get(:@model).count, page)
+      Paginated.new(partial, source.count, page)
     end
 
     delegate :each, :to => :items
+    delegate :pluck, :to => :items
     delegate :size, :[], :to => :items
   end
 end

data/lib/neo4j/railtie.rb

@@ -1,7 +1,8 @@
 require 'active_support/notifications'
+require 'rails/railtie'
 
 module Neo4j
-    class Railtie < ::Rails::Railtie
+  class Railtie < ::Rails::Railtie
     config.neo4j = ActiveSupport::OrderedOptions.new
 
     # Add ActiveModel translations to the I18n load_path
@@ -9,6 +10,11 @@ module Neo4j
     	config.i18n.load_path += Dir[File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'locales', '*.{rb,yml}')]
     end
 
+    rake_tasks do
+      load 'neo4j/tasks/neo4j_server.rake'
+      load 'neo4j/tasks/migration.rake'
+    end
+
     class << self
       def java_platform?
         RUBY_PLATFORM =~ /java/
@@ -26,7 +32,7 @@ module Neo4j
         end
 
         if cfg.sessions.empty?
-          cfg.sessions << {type: cfg.session_type, path: cfg.session_path, options: cfg.session_options}
+          cfg.sessions << { type: cfg.session_type, path: cfg.session_path, options: cfg.session_options }
         end
       end
 
@@ -45,18 +51,17 @@ module Neo4j
           raise "Tried to start embedded Neo4j db without using JRuby (got #{RUBY_PLATFORM}), please run `rvm jruby`"
         end
 
-        if (session_opts.key? :name)
-          session = Neo4j::Session.open_named(session_opts[:type], session_opts[:name], session_opts[:default], session_opts[:path])
-        else
-          session = Neo4j::Session.open(session_opts[:type], session_opts[:path], session_opts[:options])
-        end
+        session = if session_opts.key?(:name)
+                    Neo4j::Session.open_named(session_opts[:type], session_opts[:name], session_opts[:default], session_opts[:path])
+                  else
+                    Neo4j::Session.open(session_opts[:type], session_opts[:path], session_opts[:options])
+                  end
 
         start_embedded_session(session) if session_opts[:type] == :embedded_db
       end
 
     end
 
-
     # Starting Neo after :load_config_initializers allows apps to
     # register migrations in config/initializers
     initializer "neo4j.start", :after => :load_config_initializers do |app|

data/lib/neo4j/shared/persistence.rb

@@ -1,45 +1,9 @@
 module Neo4j::Shared
   module Persistence
 
-    class RecordInvalidError < RuntimeError
-      attr_reader :record
-
-      def initialize(record)
-        @record = record
-        super(@record.errors.full_messages.join(", "))
-      end
-    end
-
     extend ActiveSupport::Concern
     include Neo4j::TypeConverters
 
-    # Saves the model.
-    #
-    # If the model is new a record gets created in the database, otherwise the existing record gets updated.
-    # If perform_validation is true validations run.
-    # If any of them fail the action is cancelled and save returns false. If the flag is false validations are bypassed altogether. See ActiveRecord::Validations for more information.
-    # There’s a series of callbacks associated with save. If any of the before_* callbacks return false the action is cancelled and save returns false.
-    def save(*)
-      update_magic_properties
-      create_or_update
-    end
-
-    # Persist the object to the database.  Validations and Callbacks are included
-    # by default but validation can be disabled by passing :validate => false
-    # to #save!  Creates a new transaction.
-    #
-    # @raise a RecordInvalidError if there is a problem during save.
-    # @param (see Neo4j::Rails::Validations#save)
-    # @return nil
-    # @see #save
-    # @see Neo4j::Rails::Validations Neo4j::Rails::Validations - for the :validate parameter
-    # @see Neo4j::Rails::Callbacks Neo4j::Rails::Callbacks - for callbacks
-    def save!(*args)
-      unless save(*args)
-        raise RecordInvalidError.new(self)
-      end
-    end
-
     def update_model
       if changed_attributes && !changed_attributes.empty?
         changed_props = attributes.select{|k,v| changed_attributes.include?(k)}
@@ -49,7 +13,6 @@ module Neo4j::Shared
       end
     end
 
-
     # Convenience method to set attribute and #save at the same time
     # @param [Symbol, String] attribute of the attribute to update
     # @param [Object] value to set
@@ -66,13 +29,6 @@ module Neo4j::Shared
       self.save!
     end
 
-    # Convenience method to set multiple attributes and #save at the same time
-    # @param [Hash] attributes of names and values of attributes to set
-    def update_attributes(attributes)
-      assign_attributes(attributes)
-      self.save
-    end
-
     def create_or_update
       # since the same model can be created or updated twice from a relationship we have to have this guard
       @_create_or_updating = true
@@ -145,6 +101,7 @@ module Neo4j::Shared
 
     def reload
       return self if new_record?
+      clear_association_cache
       changed_attributes && changed_attributes.clear
       unless reload_from_database
         @_deleted = true
@@ -164,30 +121,34 @@ module Neo4j::Shared
     # Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
     # If saving fails because the resource is invalid then false will be returned.
     def update(attributes)
-      self.attributes = attributes
+      self.attributes = process_attributes(attributes)
       save
     end
     alias_method :update_attributes, :update
 
     # Same as {#update_attributes}, but raises an exception if saving fails.
     def update!(attributes)
-      self.attributes = attributes
+      self.attributes = process_attributes(attributes)
       save!
     end
     alias_method :update_attributes!, :update!
 
     def cache_key
       if self.new_record?
-        "#{self.class.model_name.cache_key}/new"
+        "#{model_cache_key}/new"
       elsif self.respond_to?(:updated_at) && !self.updated_at.blank?
-        "#{self.class.model_name.cache_key}/#{neo_id}-#{self.updated_at.utc.to_s(:number)}" 
+        "#{model_cache_key}/#{neo_id}-#{self.updated_at.utc.to_s(:number)}"
       else
-        "#{self.class.model_name.cache_key}/#{neo_id}"
+        "#{model_cache_key}/#{neo_id}"
       end
     end
 
     private
 
+    def model_cache_key
+      self.class.model_name.cache_key
+    end
+
     def create_magic_properties
     end
 
@@ -199,16 +160,9 @@ module Neo4j::Shared
       props[:_classname] = self.class.name if self.class.cached_class?
     end
 
-    # def assign_attributes(attributes)
-    #   attributes.each do |attribute, value|
-    #     send("#{attribute}=", value)
-    #   end
-    # end
-
     def set_timestamps
       self.created_at = DateTime.now if respond_to?(:created_at=)
       self.updated_at = self.created_at if respond_to?(:updated_at=)
     end
-
   end
 end