activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/core/query_ext.rb

@@ -0,0 +1,24 @@
+module Neo4j
+  module Core
+    class Query
+      # Creates a Neo4j::ActiveNode::Query::QueryProxy object that builds off of a Core::Query object.
+      #
+      # @param [Class] model An ActiveNode model to be used as the start of a new QueryuProxy chain
+      # @param [Symbol] var The variable to be used to refer to the object from within the new QueryProxy
+      # @param [Boolean] optional Indicate whether the new QueryProxy will use MATCH or OPTIONAL MATCH.
+      # @return [Neo4j::ActiveNode::Query::QueryProxy] A QueryProxy object.
+      def proxy_as(model, var, optional = false)
+        # TODO: Discuss whether it's necessary to call `break` on the query or if this should be left to the user.
+        Neo4j::ActiveNode::Query::QueryProxy.new(model, nil, node: var, optional: optional, starting_query: self, chain_level: @proxy_chain_level)
+      end
+
+      # Calls proxy_as with `optional` set true. This doesn't offer anything different from calling `proxy_as` directly but it may be more readable.
+      def proxy_as_optional(model, var)
+        proxy_as(model, var, true)
+      end
+
+      # For instances where you turn a QueryProxy into a Query and then back to a QueryProxy with `#proxy_as`
+      attr_accessor :proxy_chain_level
+    end
+  end
+end

data/lib/neo4j/core/query_find_in_batches.rb

@@ -0,0 +1,49 @@
+module Neo4j
+  module Core
+    module QueryFindInBatches
+      def find_in_batches(node_var, prop_var, options = {})
+        validate_find_in_batches_options!(options)
+
+        batch_size = options.delete(:batch_size) || 1000
+
+        query = reorder(node_var => prop_var).limit(batch_size)
+
+        records = query.to_a
+
+        while records.any?
+          records_size = records.size
+          primary_key_offset = primary_key_offset(records.last, node_var, prop_var)
+
+          yield records
+
+          break if records_size < batch_size
+
+          primary_key_var = Neo4j::Core::QueryClauses::Clause.from_key_and_single_value(node_var, prop_var)
+          records = query.where("#{primary_key_var} > {primary_key_offset}")
+                         .params(primary_key_offset: primary_key_offset).to_a
+        end
+      end
+
+      def find_each(*args, &block)
+        find_in_batches(*args) { |batch| batch.each(&block) }
+      end
+
+      private
+
+      def validate_find_in_batches_options!(options)
+        invalid_keys = options.keys.map(&:to_sym) - [:batch_size]
+        fail ArgumentError, "Invalid keys: #{invalid_keys.join(', ')}" if not invalid_keys.empty?
+      end
+
+      def primary_key_offset(last_record, node_var, prop_var)
+        last_record.send(node_var).send(prop_var)
+      rescue NoMethodError
+        begin
+          last_record.send(node_var).properties[prop_var.to_sym]
+        rescue NoMethodError
+          last_record.send("#{node_var}.#{prop_var}") # In case we're explicitly returning it
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/relationship.rb

@@ -0,0 +1,13 @@
+require 'neo4j/core/wrappable'
+
+module Neo4j
+  module Core
+    module Relationship
+      def props; properties; end
+      def neo_id; id; end
+      def start_node_neo_id; start_node_id; end
+      def end_node_neo_id; end_node_id; end
+      def rel_type; type; end
+    end
+  end
+end

data/lib/neo4j/core/responses.rb

@@ -0,0 +1,50 @@
+require 'neo4j/core/result'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module Neo4j
+  module Core
+    module Responses
+      extend ActiveSupport::Concern
+
+      included do
+        mattr_accessor :wrap_level
+      end
+
+      class_methods do
+        def result_from_data(entities_data)
+          rows = entities_data.map do |entity_data|
+            wrap(entity_data.values)
+          end
+
+          Neo4j::Core::Result.new(entities_data.keys, rows)
+        end
+
+        private
+
+        def wrap(value)
+          case value
+          when Neo4j::Driver::Types::Entity
+            wrap_by_level(value)
+          when Neo4j::Driver::Types::Path
+            value
+          when Hash
+            value.map { |key, val| [key, wrap(val)] }.to_h
+          when Enumerable
+            value.map(&method(:wrap))
+          else
+            value
+          end
+        end
+
+        def wrap_by_level(entity)
+          case wrap_level
+          when :core_entity
+            entity
+          else
+            entity.wrap
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/result.rb

@@ -0,0 +1,33 @@
+module Neo4j
+  module Core
+    class Result
+      attr_reader :columns, :rows
+
+      def initialize(columns, rows)
+        @columns = columns.map(&:to_sym)
+        @rows = rows
+        @struct_class = Struct.new(:index, *@columns)
+      end
+
+      include Enumerable
+
+      def each
+        structs.each do |struct|
+          yield struct
+        end
+      end
+
+      def structs
+        @structs ||= rows.each_with_index.map do |row, index|
+          @struct_class.new(index, *row)
+        end
+      end
+
+      def hashes
+        @hashes ||= rows.map do |row|
+          Hash[@columns.zip(row)]
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/schema.rb

@@ -0,0 +1,30 @@
+module Neo4j
+  module Core
+    module Schema
+      def version
+        result = query('CALL dbms.components()', {}, skip_instrumentation: true)
+
+        # BTW: community / enterprise could be retrieved via `result.first.edition`
+        result.first.versions[0]
+      end
+
+      def indexes
+        result = query('CALL db.indexes()', {}, skip_instrumentation: true)
+
+        result.map do |row|
+          label, property = row.description.match(/INDEX ON :([^\(]+)\(([^\)]+)\)/)[1, 2]
+          { type: row.type.to_sym, label: label.to_sym, properties: [property.to_sym], state: row.state.to_sym }
+        end
+      end
+
+      def constraints
+        result = query('CALL db.indexes()', {}, skip_instrumentation: true)
+
+        result.select { |row| row.type == 'node_unique_property' }.map do |row|
+          label, property = row.description.match(/INDEX ON :([^\(]+)\(([^\)]+)\)/)[1, 2]
+          { type: :uniqueness, label: label.to_sym, properties: [property.to_sym] }
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/schema_errors.rb

@@ -0,0 +1,12 @@
+module Neo4j
+  module Core
+    module SchemaErrors
+      class ConstraintValidationFailedError < CypherError;
+      end
+      class ConstraintAlreadyExistsError < CypherError;
+      end
+      class IndexAlreadyExistsError < CypherError;
+      end
+    end
+  end
+end

data/lib/neo4j/core/wrappable.rb

@@ -0,0 +1,30 @@
+module Neo4j
+  module Core
+    module Wrappable
+      extend ActiveSupport::Concern
+
+      def wrap
+        self.class.wrap(self)
+      end
+
+      class_methods do
+        def wrapper_callback(proc)
+          fail 'Callback already specified!' if @wrapper_callback
+          @wrapper_callback = proc
+        end
+
+        def clear_wrapper_callback
+          @wrapper_callback = nil
+        end
+
+        def wrap(node)
+          if @wrapper_callback
+            @wrapper_callback.call(node)
+          else
+            node
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/errors.rb

@@ -0,0 +1,57 @@
+module Neo4j
+  # Neo4j.rb Errors
+  # Generic Neo4j.rb exception class.
+  class Error < StandardError
+  end
+
+  # Raised when Neo4j.rb cannot find record by given id.
+  class RecordNotFound < Error
+    attr_reader :model, :primary_key, :id
+
+    def initialize(message = nil, model = nil, primary_key = nil, id = nil)
+      @primary_key = primary_key
+      @model = model
+      @id = id
+
+      super(message)
+    end
+  end
+
+  class DeprecatedSchemaDefinitionError < Error; end
+
+  class InvalidPropertyOptionsError < Error; end
+
+  class InvalidParameterError < Error; end
+
+  class UnknownTypeConverterError < Error; end
+
+  class DangerousAttributeError < ScriptError; end
+  class UnknownAttributeError < NoMethodError; end
+
+  class MigrationError < Error; end
+  class IrreversibleMigration < MigrationError; end
+  class UnknownMigrationVersionError < MigrationError; end
+
+  # Inspired/taken from active_record/migration.rb
+  class PendingMigrationError < MigrationError
+    def initialize(migrations)
+      pending_migrations = migrations.join("\n")
+      if rails? && defined?(Rails.env)
+        super("Migrations are pending:\n#{pending_migrations}\n To resolve this issue, run:\n\n        #{command_name} neo4j:migrate RAILS_ENV=#{::Rails.env}")
+      else
+        super("Migrations are pending:\n#{pending_migrations}\n To resolve this issue, run:\n\n        #{command_name} neo4j:migrate")
+      end
+    end
+
+    private
+
+    def command_name
+      return 'rake' unless rails?
+      Rails.version.to_f >= 5 ? 'bin/rails' : 'bin/rake'
+    end
+
+    def rails?
+      defined?(Rails)
+    end
+  end
+end

data/lib/neo4j/migration.rb

@@ -0,0 +1,148 @@
+require 'benchmark'
+require 'neo4j/migrations/helpers/id_property'
+
+module Neo4j
+  class Migration
+    def migrate
+      fail 'not implemented'
+    end
+
+    def output(string = '')
+      puts string unless !!ENV['MIGRATIONS_SILENCED']
+    end
+
+    def print_output(string)
+      print string unless !!ENV['MIGRATIONS_SILENCED']
+    end
+
+    def default_path
+      Rails.root if defined? Rails
+    end
+
+    def joined_path(path)
+      File.join(path.to_s, 'db', 'neo4j-migrate')
+    end
+
+    def setup
+      FileUtils.mkdir_p('db/neo4j-migrate')
+    end
+
+    def query(*args)
+      Neo4j::ActiveBase.current_driver.query(*args)
+    end
+
+    class AddIdProperty < Neo4j::Migration
+      include Neo4j::Migrations::Helpers::IdProperty
+
+      attr_reader :models_filename
+
+      def initialize(path = default_path)
+        @models_filename = File.join(joined_path(path), 'add_id_property.yml')
+      end
+
+      def migrate
+        ActiveSupport::Deprecation.warn '`AddIdProperty` task is deprecated and may be removed from future releases. '\
+                                        'Create a new migration and use the `populate_id_property` helper.', caller
+        models = ActiveSupport::HashWithIndifferentAccess.new(YAML.load_file(models_filename))[:models]
+        output 'This task will add an ID Property every node in the given file.'
+        output 'It may take a significant amount of time, please be patient.'
+        models.each do |model|
+          output
+          output
+          output "Adding IDs to #{model}"
+          populate_id_property model
+        end
+      end
+
+      def query(*args)
+        ActiveBase.magic_query(*args)
+      end
+
+      def execute(*args)
+        ActiveBase.query(*args)
+      end
+
+      def setup
+        super
+        return if File.file?(models_filename)
+
+        File.open(models_filename, 'w') do |file|
+          message = <<MESSAGE
+# Provide models to which IDs should be added.
+# # It will only modify nodes that do not have IDs. There is no danger of overwriting data.
+# # models: [Student,Lesson,Teacher,Exam]\nmodels: []
+MESSAGE
+          file.write(message)
+        end
+      end
+
+      # Might need some of this...
+      # private
+
+      # def add_ids_to(model)
+      #  max_per_batch = (ENV['MAX_PER_BATCH'] || default_max_per_batch).to_i
+
+      #  label = model.mapped_label_name
+      #  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
+
+      # def idless_count(label, id_property)
+      #  Neo4j::ActiveBase.new_query.match(n: label).where("NOT EXISTS(n.#{id_property})").pluck('COUNT(n) AS ids').first
+      # 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)\r"
+      #            else
+      #              "Running first batch...\r"
+      #            end
+
+      #  print_output message
+      # end
+
+
+      # def id_batch_set(label, id_property, new_ids, count)
+      #  tx = Neo4j::ActiveBase.new_transaction
+
+      #  Neo4j::ActiveBase.current_driver.query("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 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