activegraph 11.0.0.beta.1-java

data/lib/active_graph/core/query_ext.rb

@@ -0,0 +1,24 @@
+module ActiveGraph
+  module Core
+    class Query
+      # Creates a ActiveGraph::Node::Query::QueryProxy object that builds off of a Core::Query object.
+      #
+      # @param [Class] model An Node 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 [ActiveGraph::Node::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.
+        ActiveGraph::Node::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/active_graph/core/query_find_in_batches.rb

@@ -0,0 +1,46 @@
+module ActiveGraph
+  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 = ActiveGraph::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)
+        node = last_record[node_var]
+        return node.send(prop_var) if node&.respond_to?(prop_var)
+        return node.properties[prop_var.to_sym] if node&.respond_to?(:properties)
+        last_record["#{node_var}.#{prop_var}"] # In case we're explicitly returning it
+      end
+    end
+  end
+end

data/lib/active_graph/core/record.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'active_graph/core/result'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module ActiveGraph
+  module Core
+    module Record
+      attr_writer :wrap
+
+      def values
+        wrap(super)
+      end
+
+      def first
+        wrap(super)
+      end
+
+      def [](key)
+        wrap(super)
+      end
+
+      def to_h
+        wrap(super)
+      end
+
+      private
+
+      def wrap(value)
+        return value unless wrap?
+
+        case value
+        when Neo4j::Driver::Types::Entity
+          value.wrap
+        when Neo4j::Driver::Types::Path
+          value
+        when Hash
+          value.transform_values(&method(:wrap))
+        when Enumerable
+          value.map!(&method(:wrap))
+        else
+          value
+        end
+      end
+
+      def wrap?
+        @wrap
+      end
+    end
+  end
+end

data/lib/active_graph/core/result.rb

@@ -0,0 +1,31 @@
+module ActiveGraph
+  module Core
+    module Result
+      attr_writer :wrap
+
+      def keys
+        @keys ||= super
+      end
+
+      def wrap?
+        @wrap
+      end
+
+      def each(&block)
+        store if wrap? # TODO: why? This is preventing streaming
+        @records&.each(&block) || super
+      end
+
+      def store
+        return if @records
+        keys
+        @records = []
+        # TODO: implement 'each' without block parameter
+        method(:each).super_method.call do |record|
+          record.wrap = wrap?
+          @records << record
+        end
+      end
+    end
+  end
+end

data/lib/active_graph/core/schema.rb

@@ -0,0 +1,65 @@
+module ActiveGraph
+  module Core
+    module Schema
+      def version
+        read_transaction do
+          # BTW: community / enterprise could be retrieved via `result.first.edition`
+          query('CALL dbms.components()', {}, skip_instrumentation: true).first[:versions][0]
+        end
+      end
+
+      def indexes
+        read_transaction do
+          result = query('CALL db.indexes()', {}, skip_instrumentation: true)
+
+          result.map do |row|
+            { type: row[:type].to_sym, label: label(result, row), properties: properties(row),
+              state: row[:state].to_sym }
+          end
+        end
+      end
+
+      def constraints
+        read_transaction do
+          result = query('CALL db.indexes()', {}, skip_instrumentation: true)
+
+          result.select(&method(v4?(result) ? :v4_filter : :v3_filter)).map do |row|
+            { type: :uniqueness, label: label(result, row), properties: properties(row) }
+          end
+        end
+      end
+
+      private
+
+      def v4_filter(row)
+        row[:uniqueness] == 'UNIQUE'
+      end
+
+      def v3_filter(row)
+        row[:type] == 'node_unique_property'
+      end
+
+      def label(result, row)
+        if v34?(result)
+          row[:label]
+        else
+          (v4?(result) ? row[:labelsOrTypes] : row[:tokenNames]).first
+        end.to_sym
+      end
+
+      def v4?(result)
+        return @v4 unless @v4.nil?
+        @v4 = result.keys.include?(:labelsOrTypes)
+      end
+
+      def v34?(result)
+        return @v34 unless @v34.nil?
+        @v34 = result.keys.include?(:label)
+      end
+
+      def properties(row)
+        row[:properties].map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/active_graph/core/schema_errors.rb

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

data/lib/active_graph/core/wrappable.rb

@@ -0,0 +1,30 @@
+module ActiveGraph
+  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/active_graph/errors.rb

@@ -0,0 +1,59 @@
+module ActiveGraph
+  # 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
+
+  class Rollback < Error; end
+end

data/lib/active_graph/lazy_attribute_hash.rb

@@ -0,0 +1,38 @@
+require 'active_model/attribute_set'
+
+module ActiveGraph
+  class LazyAttributeHash < ActiveModel::LazyAttributeHash
+    def initialize(values, attr_list)
+      @types = {}
+      @values = {}
+      @additional_types = {}
+      @materialized = false
+      @delegate_hash = values
+
+      @default_attributes = process_default_attributes(attr_list)
+    end
+
+    private
+
+    def marshal_load(values)
+      initialize(values[4], values[3])
+    end
+
+    def process_default_attributes(attr_list)
+      if attr_list.is_a?(Hash)
+        attr_list
+      else
+        # initialize default attributes map with nil values
+        attr_list.each_with_object({}) do |name, map|
+          map[name] = nil
+        end
+      end
+    end
+
+    # we are using with_cast_value here because at the moment casting is being managed by
+    # Neo4j and not in ActiveModel
+    def assign_default_value(name)
+      delegate_hash[name] = ActiveModel::Attribute.with_cast_value(name, default_attributes[name].dup, nil)
+    end
+  end
+end

data/lib/active_graph/migration.rb

@@ -0,0 +1,148 @@
+require 'benchmark'
+require 'active_graph/migrations/helpers/id_property'
+
+module ActiveGraph
+  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)
+      ActiveGraph::Base.query(*args)
+    end
+
+    class AddIdProperty < ActiveGraph::Migration
+      include ActiveGraph::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)
+        Base.magic_query(*args)
+      end
+
+      def execute(*args)
+        Base.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)
+      #  ActiveGraph::Base.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 = ActiveGraph::Base.new_transaction
+
+      #  ActiveGraph::Base.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 ActiveGraph::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