neo4j 9.6.2 → 10.0.0.pre.alpha.1

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/migration.rb

@@ -28,7 +28,7 @@ module Neo4j
     end
 
     def query(*args)
-      Neo4j::ActiveBase.current_session.query(*args)
+      Neo4j::ActiveBase.current_driver.query(*args)
     end
 
     class AddIdProperty < Neo4j::Migration
@@ -115,7 +115,7 @@ MESSAGE
       # def id_batch_set(label, id_property, new_ids, count)
       #  tx = Neo4j::ActiveBase.new_transaction
 
-      #  Neo4j::ActiveBase.current_session.query("MATCH (n:`#{label}`) WHERE NOT EXISTS(n.#{id_property})
+      #  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]]|

data/lib/neo4j/migrations/base.rb

@@ -67,7 +67,7 @@ module Neo4j
       end
 
       def log_queries
-        subscriber = Neo4j::Core::CypherSession::Adaptors::Base.subscribe_to_query(&method(:output))
+        subscriber = Neo4j::Transaction.subscribe_to_query(&method(:output))
         yield
       ensure
         ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber

data/lib/neo4j/model_schema.rb

@@ -32,7 +32,7 @@ module Neo4j
       def model_constraints
         return @model_constraints if @model_constraints
 
-        constraints = Neo4j::ActiveBase.current_session.constraints.each_with_object({}) do |row, result|
+        constraints = Neo4j::Transaction.constraints.each_with_object({}) do |row, result|
           result[row[:label]] ||= []
           result[row[:label]] << row[:properties]
         end
@@ -43,7 +43,7 @@ module Neo4j
       def model_indexes
         return @model_indexes if @model_indexes
 
-        indexes = Neo4j::ActiveBase.current_session.indexes.each_with_object({}) do |row, result|
+        indexes = Neo4j::Transaction.indexes.each_with_object({}) do |row, result|
           result[row[:label]] ||= []
           result[row[:label]] << row[:properties]
         end

data/lib/neo4j/railtie.rb

@@ -1,9 +1,8 @@
 require 'active_support/notifications'
 require 'rails/railtie'
-require 'neo4j/session_manager'
 # Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
 require 'action_dispatch/railtie'
-require 'neo4j/core/cypher_session/adaptors'
+require 'neo4j/core/driver'
 
 module Neo4j
   class Railtie < ::Rails::Railtie
@@ -59,49 +58,15 @@ module Neo4j
     end
 
     def setup!(neo4j_config = empty_config)
-      wait_for_connection = neo4j_config.wait_for_connection
-      type, url, path, options = final_session_config!(neo4j_config).values_at(:type, :url, :path, :options)
-      type ||= default_session_type
+      url, path, options = final_session_config!(neo4j_config).values_at(:url, :path, :options)
       options ||= {}
-      register_neo4j_cypher_logging(type, options)
+      register_neo4j_cypher_logging
 
-      Neo4j::SessionManager.open_neo4j_session(type,
-                                               url || path || default_session_path_or_url,
-                                               wait_for_connection,
-                                               options)
+      Neo4j::ActiveBase.new_driver( url || path || default_session_path_or_url, options)
     end
 
     def final_session_config!(neo4j_config)
-      support_deprecated_session_configs!(neo4j_config)
-
-      (neo4j_config[:session].empty? ? yaml_config_data : neo4j_config[:session]).dup.tap do |result|
-        result[:type] ||= URI(result[:url]).scheme if result[:url]
-      end
-    end
-
-    def support_deprecated_session_configs!(neo4j_config)
-      if neo4j_config.sessions.present?
-        ActiveSupport::Deprecation.warn('neo4j.config.sessions is deprecated, please use neo4j.config.session (not an array)')
-        neo4j_config[:session] = neo4j_config.sessions[0] if neo4j_config[:session].empty?
-      end
-
-      %w(type path url options).each do |key|
-        value = neo4j_config.send("session_#{key}")
-        if value.present?
-          ActiveSupport::Deprecation.warn("neo4j.config.session_#{key} is deprecated, please use neo4j.config.session.#{key}")
-          neo4j_config[:session][key] = value
-        end
-      end
-    end
-
-    def default_session_type
-      if ENV['NEO4J_URL']
-        scheme = URI(ENV['NEO4J_URL']).scheme
-        fail "Invalid scheme for NEO4J_URL: #{scheme}" if !%w(http https bolt).include?(scheme)
-        scheme == 'https' ? 'http' : scheme
-      else
-        ENV['NEO4J_TYPE'] || :http
-      end.to_sym
+      (neo4j_config[:session].empty? ? yaml_config_data : neo4j_config[:session]).dup
     end
 
     def default_session_path_or_url
@@ -123,7 +88,7 @@ module Neo4j
       end.detect(&:exist?)
     end
 
-    def register_neo4j_cypher_logging(session_type, options)
+    def register_neo4j_cypher_logging
       return if @neo4j_cypher_logging_registered
 
       Neo4j::Core::Query.pretty_cypher = Neo4j::Config[:pretty_logged_cypher_queries]
@@ -131,19 +96,10 @@ module Neo4j
       logger_proc = ->(message) do
         (Neo4j::Config[:logger] ||= Rails.logger).debug message
       end
-      Neo4j::Core::CypherSession::Adaptors::Base.subscribe_to_query(&logger_proc)
-      subscribe_to_session_type_logging!(session_type, options, logger_proc)
+      Neo4j::Transaction.subscribe_to_query(&logger_proc)
+      Neo4j::Transaction.subscribe_to_request(&logger_proc)
 
       @neo4j_cypher_logging_registered = true
     end
-
-    def subscribe_to_session_type_logging!(session_type, options, logger_proc)
-      SessionManager
-        .adaptor_class(session_type, options)
-        .send(
-          [:embedded, :embedded_db].include?(session_type.to_sym) ? :subscribe_to_transaction : :subscribe_to_request,
-          &logger_proc
-        )
-    end
   end
 end

data/lib/neo4j/schema/operation.rb

@@ -7,7 +7,7 @@ module Neo4j
         @label = if label.is_a?(Neo4j::Core::Label)
                    label
                  else
-                   Neo4j::Core::Label.new(label, ActiveBase.current_session)
+                   Neo4j::Core::Label.new(label)
                  end
 
         @property = property.to_sym

data/lib/neo4j/shared.rb

@@ -14,7 +14,7 @@ module Neo4j
 
       # remove?
       def neo4j_session
-        Neo4j::ActiveBase.current_session
+        Neo4j::ActiveBase.current_driver
       end
 
       # remove?

data/lib/neo4j/shared/property.rb

@@ -80,7 +80,7 @@ module Neo4j::Shared
       end
     end
 
-    DATE_KEY_REGEX = /\A([^\(]+)\((\d+)([if])\)$/
+    DATE_KEY_REGEX = /\A([^\(]+)\((\d+)([ifs])\)$/
     # Gives support for Rails date_select, datetime_select, time_select helpers.
     def process_attributes(attributes = nil)
       return attributes if attributes.blank?

data/lib/neo4j/tasks/migration.rake

@@ -10,8 +10,7 @@ if !defined?(Rails) && !Rake::Task.task_defined?('environment')
     neo4j_url = ENV['NEO4J_URL'] || 'http://localhost:7474'
     $LOAD_PATH.unshift File.dirname('./')
     Neo4j::ActiveBase.on_establish_session do
-      type = neo4j_url =~ /^bolt/ ? :bolt : :http
-      Neo4j::SessionManager.open_neo4j_session(type, neo4j_url)
+      Neo4j::ActiveBase.new_driver(neo4j_url)
     end
   end
 end
@@ -95,12 +94,14 @@ COMMENT
         require 'neo4j/migrations/schema'
 
         args.with_defaults(remove_missing: false)
+
         schema_data = YAML.safe_load(File.read(SCHEMA_YAML_PATH), [Symbol])
+
         Neo4j::Core::CypherSession::Adaptors::Base.subscribe_to_query(&method(:puts))
+
         Neo4j::ActiveBase.run_transaction do
           Neo4j::Migrations::Schema.synchronize_schema_data(Neo4j::ActiveBase.current_session, schema_data, args[:remove_missing])
-        end
-        Neo4j::ActiveBase.run_transaction do
+
           runner = Neo4j::Migrations::Runner.new
           runner.mark_versions_as_complete(schema_data[:versions]) # Run in test mode?
         end

data/lib/neo4j/transaction.rb

@@ -0,0 +1,137 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/attribute_accessors_per_thread'
+require 'neo4j/core/querable'
+require 'neo4j/core/schema'
+
+module Neo4j
+  class Transaction
+    include Neo4j::Core::Querable
+    extend Neo4j::Core::Schema
+
+    thread_mattr_accessor :stack
+    attr_reader :root
+    attr_reader :driver_tx, :driver_session
+
+    class << self
+      # Runs the given block in a new transaction.
+      # @param [Boolean] run_in_tx if true a new transaction will not be created, instead if will simply yield to the given block
+      # @@yield [Neo4j::Transaction::Instance]
+      def run(driver, run_in_tx)
+        return yield(nil) unless run_in_tx
+
+        tx = Neo4j::Transaction.new
+        yield tx
+      rescue Exception => e # rubocop:disable Lint/RescueException
+
+        tx.mark_failed unless tx.nil?
+        raise e
+      ensure
+        tx.close unless tx.nil?
+      end
+
+      def root
+        stack.first
+      end
+    end
+
+    def initialize(_options = {})
+      (self.stack ||= []) << self
+
+      @root = stack.first
+      return unless root?
+      @driver_session = Neo4j::Core::Driver.singleton.driver.session(Neo4j::Driver::AccessMode::WRITE)
+      @driver_tx = @driver_session.begin_transaction
+    rescue StandardError => e
+      self.stack = []
+      @driver_tx.close if @driver_tx
+      @driver_session.close if @driver_session
+      raise e
+    end
+
+    # Commits or marks this transaction for rollback, depending on whether #mark_failed has been previously invoked.
+    def close
+      fail 'Tried closing when transaction stack is empty (maybe you closed too many?)' if stack.empty?
+      fail "Closed transaction which wasn't the most recent on the stack (maybe you forgot to close one?)" if stack.pop != self
+
+      post_close! if stack.empty?
+    end
+
+    # Marks this transaction as failed,
+    # which means that it will unconditionally be rolled back
+    # when #close is called.
+    # Aliased for legacy purposes.
+    def mark_failed
+      root.mark_failed if root && root != self
+      @failure = true
+    end
+
+    alias failure mark_failed
+
+    # If it has been marked as failed.
+    # Aliased for legacy purposes.
+    def failed?
+      !!@failure
+    end
+
+    alias failure? failed?
+
+    def root?
+      @root == self
+    end
+
+    def query(*args)
+      options = if args[0].is_a?(::Neo4j::Core::Query)
+                  args[1] ||= {}
+                else
+                  args[1] ||= {}
+                  args[2] ||= {}
+                end
+      options[:transaction] ||= self
+
+      self.class.query(*args)
+    end
+
+    def queries(options = {}, &block)
+      self.class.queries({ transaction: self }.merge(options), &block)
+    end
+
+    def after_commit_registry
+      @after_commit_registry ||= []
+    end
+
+    def after_commit(&block)
+      after_commit_registry << block
+    end
+
+    def commit
+      return unless root?
+      begin
+        @driver_tx.success
+        @driver_tx.close
+      ensure
+        @driver_session.close
+      end
+    end
+
+    def delete
+      root.driver_tx.failure
+      root.driver_tx.close
+      root.driver_session.close
+    end
+
+    def root_tx
+      root.driver_tx
+    end
+
+    private
+
+    def post_close!
+      if failed?
+        delete
+      else
+        commit
+        after_commit_registry.each(&:call)
+      end
+    end
+  end
+end