neo4j 7.2.3 → 8.0.0.alpha.1

data/lib/neo4j/migrations.rb

@@ -0,0 +1,10 @@
+module Neo4j
+  module Migrations
+    extend ActiveSupport::Autoload
+    autoload :Helpers
+    autoload :MigrationFile
+    autoload :Base
+    autoload :Runner
+    autoload :SchemaMigration
+  end
+end

data/lib/neo4j/migrations/base.rb

@@ -0,0 +1,44 @@
+module Neo4j
+  module Migrations
+    class Base < ::Neo4j::Migration
+      include Neo4j::Migrations::Helpers
+      include Neo4j::Migrations::Helpers::Schema
+      include Neo4j::Migrations::Helpers::IdProperty
+      include Neo4j::Migrations::Helpers::Relationships
+
+      def initialize(migration_id)
+        @migration_id = migration_id
+      end
+
+      def migrate(method)
+        ensure_schema_migration_constraint
+        Benchmark.realtime do
+          ActiveBase.run_transaction(transactions?) do
+            if method == :up
+              up
+              SchemaMigration.create!(migration_id: @migration_id)
+            else
+              down
+              SchemaMigration.find_by!(migration_id: @migration_id).destroy
+            end
+          end
+        end
+      end
+
+      def up
+        fail NotImplementedError
+      end
+
+      def down
+        fail NotImplementedError
+      end
+
+      private
+
+      def ensure_schema_migration_constraint
+        SchemaMigration.first
+        Neo4j::Core::Label.wait_for_schema_changes(ActiveBase.current_session)
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/helpers.rb

@@ -0,0 +1,101 @@
+require 'benchmark'
+
+module Neo4j
+  module Migrations
+    module Helpers
+      extend ActiveSupport::Concern
+      extend ActiveSupport::Autoload
+
+      autoload :Schema
+      autoload :IdProperty
+      autoload :Relationships
+
+      PROPERTY_ALREADY_DEFINED = 'Property `%{new_property}` is already defined in `%{label}`. '\
+                                 'To overwrite, call `remove_property(:%{label}, :%{new_property})` before this method.'.freeze
+
+      def remove_property(label, property)
+        by_label(label).remove(n: property).exec
+      end
+
+      def rename_property(label, old_property, new_property)
+        fail Neo4j::MigrationError, format(PROPERTY_ALREADY_DEFINED, new_property: new_property, label: label) if property_exists?(label, new_property)
+        by_label(label).set("n.#{new_property} = n.#{old_property}")
+                       .remove("n.#{old_property}").exec
+      end
+
+      def drop_nodes(label)
+        query.match(n: label)
+             .optional_match('(n)-[r]-()')
+             .delete(:r, :n).exec
+      end
+
+      def add_labels(label, new_labels)
+        by_label(label).set(n: new_labels).exec
+      end
+
+      def add_label(label, new_label)
+        add_labels(label, [new_label])
+      end
+
+      def remove_labels(label, labels_to_remove)
+        by_label(label).remove(n: labels_to_remove).exec
+      end
+
+      def remove_label(label, label_to_remove)
+        remove_labels(label, [label_to_remove])
+      end
+
+      def rename_label(old_label, new_label)
+        by_label(old_label).set(n: new_label).remove(n: old_label).exec
+      end
+
+      def execute(string, params = {})
+        ActiveBase.query(string, params).to_a
+      end
+
+      def say_with_time(message)
+        say(message)
+        result = nil
+        time = Benchmark.measure { result = yield }
+        say format('%.4fs', time.real), :subitem
+        say("#{result} rows", :subitem) if result.is_a?(Integer)
+        result
+      end
+
+      def say(message, subitem = false)
+        output "#{subitem ? '   ->' : '--'} #{message}"
+      end
+
+      def query(*args)
+        ActiveBase.new_query(*args)
+      end
+
+      protected
+
+      def transactions?
+        self.class.transaction?
+      end
+
+      private
+
+      def property_exists?(label, property)
+        by_label(label).where("EXISTS(n.#{property})").return(:n).any?
+      end
+
+      def by_label(label, options = {})
+        symbol = options[:symbol] || :n
+        query.match(symbol => label)
+      end
+
+      module ClassMethods
+        def disable_transactions!
+          @disable_transactions = true
+        end
+
+        def transaction?
+          !@disable_transactions
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/helpers/id_property.rb

@@ -0,0 +1,75 @@
+module Neo4j
+  module Migrations
+    module Helpers
+      module IdProperty
+        extend ActiveSupport::Concern
+
+        def populate_id_property(label)
+          model = label.to_s.constantize
+          max_per_batch = (ENV['MAX_PER_BATCH'] || default_max_per_batch).to_i
+
+          last_time_taken = nil
+
+          until (nodes_left = idless_count(label, model.primary_key)) == 0
+            print_status(last_time_taken, max_per_batch, nodes_left)
+
+            count = [nodes_left, max_per_batch].min
+            last_time_taken = Benchmark.realtime do
+              max_per_batch = id_batch_set(label, model.primary_key, Array.new(count) { new_id_for(model) }, count)
+            end
+          end
+        end
+
+        protected
+
+        def idless_count(label, id_property)
+          query.match(n: label).where("NOT EXISTS(n.#{id_property})").pluck('COUNT(n) AS ids').first
+        end
+
+        def id_batch_set(label, id_property, new_ids, count)
+          tx = ActiveBase.new_transaction
+
+          execute("MATCH (n:`#{label}`) WHERE NOT EXISTS(n.#{id_property})
+            with COLLECT(n) as nodes, #{new_ids} as ids
+            FOREACH(i in range(0,#{count - 1})|
+              FOREACH(node in [nodes[i]]|
+                SET node.#{id_property} = ids[i]))
+            RETURN distinct(true)
+            LIMIT #{count}")
+
+          count
+        rescue Neo4j::Server::CypherResponse::ResponseError, Faraday::TimeoutError
+          new_max_per_batch = (max_per_batch * 0.8).round
+          output "Error querying #{max_per_batch} nodes. Trying #{new_max_per_batch}"
+          new_max_per_batch
+        ensure
+          tx.close
+        end
+
+        def print_status(last_time_taken, max_per_batch, nodes_left)
+          time_per_node = last_time_taken / max_per_batch if last_time_taken
+          message = if time_per_node
+                      eta_seconds = (nodes_left * time_per_node).round
+                      "#{nodes_left} nodes left.  Last batch: #{(time_per_node * 1000.0).round(1)}ms / node (ETA: #{eta_seconds / 60} minutes)"
+                    else
+                      'Running first batch...'
+                    end
+
+          output message
+        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
+    end
+  end
+end

data/lib/neo4j/migrations/helpers/relationships.rb

@@ -0,0 +1,66 @@
+module Neo4j
+  module Migrations
+    module Helpers
+      module Relationships
+        extend ActiveSupport::Concern
+
+        DEFAULT_MAX_PER_BATCH = 1000
+
+        def change_relations_style(relationships, old_style, new_style, params = {})
+          relationships.each do |rel|
+            relabel_relation(relationship_style(rel, old_style), relationship_style(rel, new_style), params)
+          end
+        end
+
+        def relabel_relation(old_name, new_name, params = {})
+          relation_query = match_relation(old_name, params)
+
+          max_per_batch = (ENV['MAX_PER_BATCH'] || DEFAULT_MAX_PER_BATCH).to_i
+
+          count = count_relations(relation_query)
+          output "Indexing #{count} #{old_name}s into #{new_name}..."
+          while count > 0
+            relation_query.create("(a)-[r2:`#{new_name}`]->(b)").set('r2 = r').with(:r).limit(max_per_batch).delete(:r).exec
+            count = count_relations(relation_query)
+            output "... #{count} #{old_name}'s left to go.." if count > 0
+          end
+        end
+
+        private
+
+        def match_relation(label, params = {})
+          from = params[:from] ? "(a:`#{params[:from]}`)" : '(a)'
+          to = params[:to] ? "(b:`#{params[:to]}`)" : '(b)'
+          relation = arrow_cypher(label, params[:direction])
+
+          query.match("#{from}#{relation}#{to}")
+        end
+
+        def arrow_cypher(label, direction)
+          case direction
+          when :in
+            "<-[r:`#{label}`]-"
+          when :both
+            "<-[r:`#{label}`]->"
+          else
+            "-[r:`#{label}`]->"
+          end
+        end
+
+        def count_relations(query)
+          query.pluck('COUNT(r)').first
+        end
+
+        def relationship_style(relationship, format)
+          case format.to_s
+          when 'lower_hashtag' then "##{relationship.downcase}"
+          when 'lower'         then relationship.downcase
+          when 'upper'         then relationship.upcase
+          else
+            fail("Invalid relationship type style `#{format}`.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/helpers/schema.rb

@@ -0,0 +1,53 @@
+module Neo4j
+  module Migrations
+    module Helpers
+      module Schema
+        extend ActiveSupport::Concern
+        MISSING_CONSTRAINT_OR_INDEX = 'No such %{type} for %{label}#%{property}'.freeze
+        DUPLICATE_CONSTRAINT_OR_INDEX = 'Duplicate %{type} for %{label}#%{property}'.freeze
+
+        def add_constraint(label, property, options = {})
+          force = options[:force] || false
+          label_object = ActiveBase.label_object(label)
+          fail_duplicate_constraint_or_index!(:constraint, label, property) if !force && label_object.constraint?(property)
+          label_object.create_constraint(property, type: :uniqueness)
+        end
+
+        def add_index(label, property, options = {})
+          force = options[:force] || false
+          label_object = ActiveBase.label_object(label)
+          fail_duplicate_constraint_or_index!(:index, label, property) if !force && label_object.index?(property)
+          label_object.create_index(property)
+        end
+
+        def force_add_index(label, property)
+          add_index(label, property)
+        end
+
+        def drop_constraint(label, property)
+          label_object = ActiveBase.label_object(label)
+          fail_missing_constraint_or_index!(:constraint, label, property) if !label_object.constraint?(property)
+          label_object.drop_constraint(property, type: :uniqueness)
+        end
+
+        def drop_index(label, property)
+          label_object = ActiveBase.label_object(label)
+          fail_missing_constraint_or_index!(:index, label, property) if !label_object.index?(property)
+          label_object.drop_index(property)
+        end
+
+        protected
+
+        def fail_missing_constraint_or_index!(type, label, property)
+          fail Neo4j::MigrationError,
+               format(MISSING_CONSTRAINT_OR_INDEX, type: type, label: label, property: property)
+        end
+
+        def fail_duplicate_constraint_or_index!(type, label, property)
+          fail Neo4j::MigrationError,
+               format(DUPLICATE_CONSTRAINT_OR_INDEX, type: type, label: label, property: property)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/migration_file.rb

@@ -0,0 +1,24 @@
+module Neo4j
+  module Migrations
+    class MigrationFile
+      attr_reader :file_name, :symbol_name, :class_name, :version
+
+      def initialize(file_name)
+        @file_name = file_name
+        extract_data!
+      end
+
+      def create
+        require @file_name
+        class_name.constantize.new(@version)
+      end
+
+      private
+
+      def extract_data!
+        @version, @symbol_name = File.basename(@file_name, '.rb').split('_', 2)
+        @class_name = @symbol_name.camelize
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/runner.rb

@@ -0,0 +1,110 @@
+module Neo4j
+  module Migrations
+    class Runner
+      STATUS_TABLE_FORMAT = '%-10s %-20s %s'.freeze
+      SEPARATOR = '--------------------------------------------------'.freeze
+      FILE_MISSING = '**** file missing ****'.freeze
+      STATUS_TABLE_HEADER = ['Status'.freeze, 'Migration ID'.freeze, 'Migration Name'.freeze].freeze
+      UP_MESSAGE = 'up'.freeze
+      DOWN_MESSAGE = 'down'.freeze
+      MIGRATION_RUNNING = {up: 'running'.freeze, down: 'reverting'.freeze}.freeze
+      MIGRATION_DONE = {up: 'migrated'.freeze, down: 'reverted'.freeze}.freeze
+
+      def initialize
+        SchemaMigration.mapped_label.create_constraint(:migration_id, type: :unique)
+        @up_versions = SortedSet.new(SchemaMigration.all.pluck(:migration_id))
+      end
+
+      def all
+        migration_files.each do |migration_file|
+          next if up?(migration_file.version)
+          migrate(:up, migration_file)
+        end
+      end
+
+      def up(version)
+        migration_file = find_by_version!(version)
+        return if up?(version)
+        migrate(:up, migration_file)
+      end
+
+      def down(version)
+        migration_file = find_by_version!(version)
+        return unless up?(version)
+        migrate(:down, migration_file)
+      end
+
+      def rollback(steps)
+        @up_versions.to_a.reverse.first(steps).each do |version|
+          down(version)
+        end
+      end
+
+      def status
+        output STATUS_TABLE_FORMAT, *STATUS_TABLE_HEADER
+        output SEPARATOR
+        all_migrations.each do |version|
+          status = up?(version) ? UP_MESSAGE : DOWN_MESSAGE
+          migration_file = find_by_version(version)
+          migration_name = migration_file ? migration_file.class_name : FILE_MISSING
+          output STATUS_TABLE_FORMAT, status, version, migration_name
+        end
+      end
+
+      private
+
+      def up?(version)
+        @up_versions.include?(version)
+      end
+
+      def migrate(direction, migration_file)
+        migration_message(direction, migration_file) do
+          migration = migration_file.create
+          migration.migrate(direction)
+        end
+      end
+
+      def migration_message(direction, migration)
+        output "== #{migration.version} #{migration.class_name}: #{MIGRATION_RUNNING[direction]}... ========="
+        yield
+        output "== #{migration.version} #{migration.class_name}: #{MIGRATION_DONE[direction]} ========="
+      end
+
+      def output(*string_format)
+        puts format(*string_format) unless !!ENV['MIGRATIONS_SILENCED']
+      end
+
+      def find_by_version!(version)
+        find_by_version(version) || fail(UnknownMigrationVersionError, "No such migration #{version}")
+      end
+
+      def find_by_version(version)
+        migration_files.find { |file| file.version == version }
+      end
+
+      def all_migrations
+        @up_versions + files_versions
+      end
+
+      def files_versions
+        migration_files.map(&:version)
+      end
+
+      def migration_files
+        files.map { |file_path| MigrationFile.new(file_path) }
+      end
+
+      def files
+        Dir[files_path].sort
+      end
+
+      def files_path
+        app_root.join('db', 'neo4j', 'migrate', '*.rb')
+      end
+
+      def app_root
+        defined?(Rails) ? Rails.root : Pathname.new('.')
+      end
+    end
+  end
+end