activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/migrations.rb

@@ -0,0 +1,27 @@
+module Neo4j
+  module Migrations
+    extend ActiveSupport::Autoload
+    autoload :Helpers
+    autoload :MigrationFile
+    autoload :Base
+    autoload :Runner
+    autoload :SchemaMigration
+    autoload :CheckPending
+
+    class << self
+      def check_for_pending_migrations!
+        return if Neo4j::Config.configuration['skip_migration_check']
+
+        runner = Neo4j::Migrations::Runner.new
+        pending = runner.pending_migrations
+        fail ::Neo4j::PendingMigrationError, pending if pending.any?
+      end
+
+      attr_accessor :currently_running_migrations
+
+      def maintain_test_schema!
+        Neo4j::Migrations::Runner.new(silenced: true).all
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/base.rb

@@ -0,0 +1,77 @@
+module Neo4j
+  module Migrations
+    class Base
+      include Neo4j::Migrations::Helpers
+      include Neo4j::Migrations::Helpers::Schema
+      include Neo4j::Migrations::Helpers::IdProperty
+      include Neo4j::Migrations::Helpers::Relationships
+
+      def initialize(migration_id, options = {})
+        @migration_id = migration_id
+        @silenced = options[:silenced]
+      end
+
+      def migrate(method)
+        Benchmark.realtime do
+          method == :up ? migrate_up : migrate_down
+        end
+      end
+
+      def up
+        fail NotImplementedError
+      end
+
+      def down
+        fail NotImplementedError
+      end
+
+      private
+
+      def migrate_up
+        schema = SchemaMigration.create!(migration_id: @migration_id, incomplete: true)
+        begin
+          run_migration(:up)
+        rescue StandardError => e
+          schema.destroy if transactions?
+          handle_migration_error!(e)
+        else
+          schema.update!(incomplete: nil)
+        end
+      end
+
+      def migrate_down
+        schema = SchemaMigration.find_by!(migration_id: @migration_id)
+        schema.update!(incomplete: true)
+        begin
+          run_migration(:down)
+        rescue StandardError => e
+          schema.update!(incomplete: nil) if transactions?
+          handle_migration_error!(e)
+        else
+          schema.destroy
+        end
+      end
+
+      def run_migration(direction)
+        migration_transaction { log_queries { public_send(direction) } }
+      end
+
+      def handle_migration_error!(e)
+        fail e unless e.message =~ /Cannot perform data updates in a transaction that has performed schema updates./
+        fail MigrationError,
+             "#{e.message}. Please add `disable_transactions!` in your migration file."
+      end
+
+      def migration_transaction(&block)
+        ActiveBase.run_transaction(transactions?, &block)
+      end
+
+      def log_queries
+        subscriber = Neo4j::Transaction.subscribe_to_query(&method(:output))
+        yield
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/check_pending.rb

@@ -0,0 +1,20 @@
+module Neo4j
+  module Migrations
+    class CheckPending
+      def initialize(app)
+        @app = app
+        @last_check = 0
+      end
+
+      def call(env)
+        latest_migration = Neo4j::Migrations::Runner.latest_migration
+        mtime = latest_migration ? latest_migration.version.to_i : 0
+        if @last_check < mtime
+          Neo4j::Migrations.check_for_pending_migrations!
+          @last_check = mtime
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/helpers.rb

@@ -0,0 +1,105 @@
+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 output(*string_format)
+        puts format(*string_format) unless @silenced
+      end
+
+      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,51 @@
+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
+          type = options[:type] || :uniqueness
+          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: type)
+        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 drop_constraint(label, property, options = {})
+          type = options[:type] || :uniqueness
+          label_object = ActiveBase.label_object(label)
+          fail_missing_constraint_or_index!(:constraint, label, property) if !options[:force] && !label_object.constraint?(property)
+          label_object.drop_constraint(property, type: type)
+        end
+
+        def drop_index(label, property, options = {})
+          label_object = ActiveBase.label_object(label)
+          fail_missing_constraint_or_index!(:index, label, property) if !options[:force] && !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(options = {})
+        require @file_name
+        class_name.constantize.new(@version, options)
+      end
+
+      private
+
+      def extract_data!
+        @version, @symbol_name = File.basename(@file_name, '.rb').split('_', 2)
+        @class_name = @symbol_name.camelize
+      end
+    end
+  end
+end