neo4j-core 6.1.6 → 7.0.0.alpha.1

data/lib/neo4j/core/cypher_session/transactions/embedded.rb

@@ -0,0 +1,32 @@
+require 'neo4j/core/cypher_session/transactions'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Transactions
+        class Embedded < Base
+          def initialize(*args)
+            super
+            @java_tx = adaptor.graph_db.begin_tx
+          end
+
+          def commit
+            return if !@java_tx
+
+            @java_tx.success
+            @java_tx.close
+          rescue Java::OrgNeo4jGraphdb::TransactionFailureException => e
+            raise CypherError, e.message
+          end
+
+          def delete
+            return if !@java_tx
+
+            @java_tx.failure
+            @java_tx.close
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/transactions/http.rb

@@ -0,0 +1,52 @@
+require 'neo4j/core/cypher_session/transactions'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Transactions
+        class HTTP < Base
+          # Should perhaps have transaction adaptors only define #close
+          # commit/delete are, I think, an implementation detail
+
+          def commit
+            adaptor.requestor.request(:post, query_path(true)) if started?
+          end
+
+          def delete
+            adaptor.requestor.request(:delete, query_path) if started?
+          end
+
+          def query_path(commit = false)
+            if id
+              "/db/data/transaction/#{id}"
+            else
+              '/db/data/transaction'
+            end.tap do |path|
+              path << '/commit' if commit
+            end
+          end
+
+          # Takes the transaction URL from Neo4j and parses out the ID
+          def apply_id_from_url!(url)
+            root.instance_variable_set('@id', url.match(%r{/(\d+)/?$})[1].to_i) if url
+            # @id = url.match(%r{/(\d+)/?$})[1].to_i if url
+          end
+
+          def started?
+            !!id
+          end
+
+          def id
+            root.instance_variable_get('@id')
+          end
+
+          private
+
+          def connection
+            adaptor.connection
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/instrumentable.rb

@@ -12,13 +12,13 @@ module Neo4j
       end
 
       module ClassMethods
-        def instrument(name, label, arguments, &block)
+        def instrument(name, label, arguments)
           # defining class methods
           klass = class << self; self; end
           klass.instance_eval do
             define_method("subscribe_to_#{name}") do |&b|
               ActiveSupport::Notifications.subscribe(label) do |a, start, finish, id, payload|
-                b.call block.call(a, start, finish, id, payload)
+                b.call yield(a, start, finish, id, payload)
               end
             end
 

data/lib/neo4j/core/label.rb

@@ -0,0 +1,182 @@
+module Neo4j
+  module Core
+    class Label
+      attr_reader :name
+
+      def initialize(name, session)
+        @name = name
+        @session = session
+      end
+
+      def create_index(property, options = {})
+        validate_index_options!(options)
+        properties = property.is_a?(Array) ? property.join(',') : property
+        schema_query("CREATE INDEX ON :`#{@name}`(#{properties})")
+      end
+
+      def drop_index(property, options = {})
+        validate_index_options!(options)
+        schema_query("DROP INDEX ON :`#{@name}`(#{property})")
+      end
+
+      # Creates a neo4j constraint on a property
+      # See http://docs.neo4j.org/chunked/stable/query-constraints.html
+      # @example
+      #   label = Neo4j::Label.create(:person, session)
+      #   label.create_constraint(:name, {type: :unique}, session)
+      #
+      def create_constraint(property, constraints)
+        cypher = case constraints[:type]
+                 when :unique, :uniqueness
+                   "CREATE CONSTRAINT ON (n:`#{name}`) ASSERT n.`#{property}` IS UNIQUE"
+                 else
+                   fail "Not supported constraint #{constraints.inspect} for property #{property} (expected :type => :unique)"
+                 end
+        schema_query(cypher)
+      end
+
+      def create_uniqueness_constraint(property, options = {})
+        create_constraint(property, options.merge(type: :unique))
+      end
+
+      # Drops a neo4j constraint on a property
+      # See http://docs.neo4j.org/chunked/stable/query-constraints.html
+      # @example
+      #   label = Neo4j::Label.create(:person, session)
+      #   label.create_constraint(:name, {type: :unique}, session)
+      #   label.drop_constraint(:name, {type: :unique}, session)
+      #
+      def drop_constraint(property, constraint)
+        cypher = case constraint[:type]
+                 when :unique, :uniqueness
+                   "DROP CONSTRAINT ON (n:`#{name}`) ASSERT n.`#{property}` IS UNIQUE"
+                 else
+                   fail "Not supported constraint #{constraint.inspect}"
+                 end
+        schema_query(cypher)
+      end
+
+      def drop_uniqueness_constraint(property, options = {})
+        drop_constraint(property, options.merge(type: :unique))
+      end
+
+      def indexes
+        @session.indexes.select do |definition|
+          definition[:label] == @name.to_sym
+        end
+      end
+
+      def self.indexes_for(session)
+        session.indexes
+      end
+
+      def drop_indexes
+        indexes.each do |definition|
+          begin
+            @session.query("DROP INDEX ON :`#{definition[:label]}`(#{definition[:properties][0]})")
+          rescue Neo4j::Server::CypherResponse::ResponseError
+            # This will error on each constraint. Ignore and continue.
+            next
+          end
+        end
+      end
+
+      def self.drop_indexes_for(session)
+        indexes_for(session).each do |definition|
+          begin
+            session.query("DROP INDEX ON :`#{definition[:label]}`(#{definition[:properties][0]})")
+          rescue Neo4j::Server::CypherResponse::ResponseError
+            # This will error on each constraint. Ignore and continue.
+            next
+          end
+        end
+      end
+
+      def index?(property)
+        indexes.any? { |definition| definition[:properties] == [property.to_sym] }
+      end
+
+      def constraints(_options = {})
+        @session.constraints.select do |definition|
+          definition[:label] == @name.to_sym
+        end
+      end
+
+      def uniqueness_constraints(_options = {})
+        constraints.select do |definition|
+          definition[:type] == :uniqueness
+        end
+      end
+
+      def drop_uniqueness_constraints
+        uniqueness_constraints.each do |definition|
+          @session.query("DROP CONSTRAINT ON (n:`#{definition[:label]}`) ASSERT n.`#{definition[:properties][0]}` IS UNIQUE")
+        end
+      end
+
+      def self.drop_uniqueness_constraints_for(session)
+        session.constraints.each do |definition|
+          session.query("DROP CONSTRAINT ON (n:`#{definition[:label]}`) ASSERT n.`#{definition[:properties][0]}` IS UNIQUE")
+        end
+      end
+
+      def constraint?(property)
+        constraints.any? { |definition| definition[:properties] == [property.to_sym] }
+      end
+
+      def uniqueness_constraint?(property)
+        uniqueness_constraints.include?([property])
+      end
+
+      def self.wait_for_schema_changes(session)
+        schema_threads(session).map(&:join)
+        set_schema_threads(session, [])
+      end
+
+      private
+
+      # Store schema threads on the session so that we can easily wait for all
+      # threads on a session regardless of label
+      def schema_threads
+        self.class.schema_threads(@session)
+      end
+
+      def schema_threads=(array)
+        self.class.set_schema_threads(@session, array)
+      end
+
+      class << self
+        def schema_threads(session)
+          session.instance_variable_get('@_schema_threads') || []
+        end
+
+        def set_schema_threads(session, array)
+          session.instance_variable_set('@_schema_threads', array)
+        end
+      end
+
+      # Schema queries can run separately from other queries, but they should
+      # be mutually exclusive to each other or we get locking errors
+      # SCHEMA_QUERY_SEMAPHORE = Mutex.new
+
+      # If there is a transaction going on, this could block
+      # So we run in a thread and it will go through at the next opportunity
+      def schema_query(cypher)
+        # Thread.new do
+        # SCHEMA_QUERY_SEMAPHORE.synchronize do
+
+        @session.transaction { |tx| tx.query(cypher, {}) }
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        puts 'ERROR during schema query:', e.message, e.backtrace
+
+        # end
+        # end.tap { |thread| schema_threads << thread }
+      end
+
+      def validate_index_options!(options)
+        return unless options[:type] && options[:type] != :exact
+        fail "Type #{options[:type]} is not supported"
+      end
+    end
+  end
+end

data/lib/neo4j/core/node.rb

@@ -1,20 +1,25 @@
 require 'neo4j/core/wrappable'
+require 'active_support/core_ext/hash/keys'
 
 module Neo4j
   module Core
     class Node
       attr_reader :id, :labels, :properties
-      alias_method :props, :properties
+      alias props properties
 
       include Wrappable
 
       # Perhaps we should deprecate this?
-      alias_method :neo_id, :id
+      alias neo_id id
 
       def initialize(id, labels, properties = {})
         @id = id
         @labels = labels.map(&:to_sym) unless labels.nil?
-        @properties = properties
+        @properties = properties.symbolize_keys
+      end
+
+      def ==(other)
+        other.is_a?(Node) && neo_id == other.neo_id
       end
 
       class << self

data/lib/neo4j/core/relationship.rb

@@ -1,14 +1,22 @@
+require 'neo4j/core/wrappable'
+require 'active_support/core_ext/hash/keys'
+
 module Neo4j
   module Core
     class Relationship
-      attr_reader :id, :type, :properties
+      attr_reader :id, :type, :properties, :start_node_id, :end_node_id
+      alias props properties
+      alias neo_id id
+      alias rel_type type
 
       include Wrappable
 
-      def initialize(id, type, properties)
+      def initialize(id, type, properties, start_node_id = nil, end_node_id = nil)
         @id = id
         @type = type.to_sym unless type.nil?
-        @properties = properties
+        @properties = properties.symbolize_keys
+        @start_node_id = start_node_id
+        @end_node_id = end_node_id
       end
 
       class << self
@@ -17,7 +25,7 @@ module Neo4j
           type = nil # unknown
           properties = properties
 
-          new(id, type, properties)
+          new(id, type, properties, nil, nil)
         end
       end
     end

data/lib/neo4j/entity_equality.rb

@@ -3,6 +3,6 @@ module Neo4j
     def ==(other)
       other.class == self.class && other.neo_id == neo_id
     end
-    alias_method :eql?, :==
+    alias eql? ==
   end
 end

data/lib/neo4j/session.rb

@@ -36,11 +36,6 @@ module Neo4j
       true # TODO
     end
 
-    # @abstract
-    def begin_tx
-      fail 'not impl.'
-    end
-
     class CypherError < StandardError
       attr_reader :error_msg, :error_status, :error_code
       def initialize(error_msg, error_code, error_status)
@@ -77,6 +72,10 @@ module Neo4j
       fail 'not implemented'
     end
 
+    def transaction_class
+      self.class.transaction_class
+    end
+
     class << self
       # Creates a new session to Neo4j.
       # This will be the default session to be used unless there is already a session created (see #current and #set_current)

data/lib/neo4j/transaction.rb

@@ -1,39 +1,86 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/per_thread_registry'
+
 module Neo4j
   module Transaction
     extend self
 
-    module Instance
-      # @private
-      def register_instance
-        @pushed_nested = 0
-        Neo4j::Transaction.register(self)
+    # Provides a simple API to manage transactions for each session in a thread-safe manner
+    class TransactionsRegistry
+      extend ActiveSupport::PerThreadRegistry
+
+      attr_accessor :transactions_by_session_id
+    end
+
+    class Base
+      attr_reader :session, :root
+
+      def initialize(session, _options = {})
+        @session = session
+
+        Transaction.stack_for(session) << self
+
+        @root = Transaction.stack_for(session).first
+        # Neo4j::Core::Label::SCHEMA_QUERY_SEMAPHORE.lock if root?
+
+        # @parent = session_transaction_stack.last
+        # session_transaction_stack << self
       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
-        @failure = true
+      def inspect
+        status_string = [:id, :failed?, :active?, :commit_url].map do |method|
+          "#{method}: #{send(method)}" if respond_to?(method)
+        end.compact.join(', ')
+
+        "<#{self.class} [#{status_string}]"
       end
-      alias_method :failure, :mark_failed
 
-      # If it has been marked as failed. Aliased for legacy purposes.
-      def failed?
-        !!@failure
+      # Commits or marks this transaction for rollback, depending on whether #mark_failed has been previously invoked.
+      def close
+        tx_stack = Transaction.stack_for(@session)
+        fail 'Tried closing when transaction stack is empty (maybe you closed too many?)' if tx_stack.empty?
+        fail "Closed transaction which wasn't the most recent on the stack (maybe you forgot to close one?)" if tx_stack.pop != self
+
+        @closed = true
+
+        post_close! if tx_stack.empty?
+      end
+
+      def delete
+        fail 'not implemented'
+      end
+
+      def commit
+        fail 'not implemented'
       end
-      alias_method :failure?, :failed?
 
       def autoclosed!
         @autoclosed = true if transient_failures_autoclose?
       end
 
-      def transient_failures_autoclose?
-        Neo4j::Session.current.version >= '2.2.6'
+      def closed?
+        !!@closed
       end
 
-      def autoclosed?
-        !!@autoclosed
+      # 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 mark_expired
+        @parent.mark_expired if @parent
         @expired = true
       end
 
@@ -41,43 +88,24 @@ module Neo4j
         !!@expired
       end
 
-      # @private
-      def push_nested!
-        @pushed_nested += 1
+      def root?
+        @root == self
       end
 
-      # @private
-      def pop_nested!
-        @pushed_nested -= 1
-      end
+      private
 
-      # Only for the embedded neo4j !
-      # Acquires a read lock for entity for this transaction.
-      # See neo4j java docs.
-      # @param [Neo4j::Node,Neo4j::Relationship] entity
-      # @return [Java::OrgNeo4jKernelImplCoreapi::PropertyContainerLocker]
-      def acquire_read_lock(entity)
+      def transient_failures_autoclose?
+        Gem::Version.new(@session.version) >= Gem::Version.new('2.2.6')
       end
 
-      # Only for the embedded neo4j !
-      # Acquires a write lock for entity for this transaction.
-      # See neo4j java docs.
-      # @param [Neo4j::Node,Neo4j::Relationship] entity
-      # @return [Java::OrgNeo4jKernelImplCoreapi::PropertyContainerLocker]
-      def acquire_write_lock(entity)
+      def autoclosed?
+        !!@autoclosed
       end
 
-      # Commits or marks this transaction for rollback, depending on whether failure() has been previously invoked.
-      def close
-        pop_nested!
-        return if @pushed_nested >= 0
-        fail "Can't commit transaction, already committed" if @pushed_nested < -1
-        Neo4j::Transaction.unregister(self)
-        post_close!
+      def active?
+        !closed?
       end
 
-      private
-
       def post_close!
         return if autoclosed?
         if failed?
@@ -89,56 +117,64 @@ module Neo4j
     end
 
     # @return [Neo4j::Transaction::Instance]
-    def new(current = Session.current!)
-      current.begin_tx
+    def new(session = Session.current!)
+      session.transaction
     end
 
     # 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(run_in_tx = true)
+    def run(*args)
+      session, run_in_tx = session_and_run_in_tx_from_args(args)
+
       fail ArgumentError, 'Expected a block to run in Transaction.run' unless block_given?
 
       return yield(nil) unless run_in_tx
 
-      tx = Neo4j::Transaction.new
+      tx = Neo4j::Transaction.new(session)
       yield tx
     rescue Exception => e # rubocop:disable Lint/RescueException
-      print_exception_cause(e)
+      # print_exception_cause(e)
+
       tx.mark_failed unless tx.nil?
-      raise
+      raise e
     ensure
       tx.close unless tx.nil?
     end
 
-    # @return [Neo4j::Transaction]
-    def current
-      Thread.current[:neo4j_curr_tx]
-    end
-
-    # @private
-    def print_exception_cause(exception)
-      return if !exception.respond_to?(:cause) || !exception.cause.respond_to?(:print_stack_trace)
+    # To support old syntax of providing run_in_tx first
+    # But session first is ideal
+    def session_and_run_in_tx_from_args(args)
+      fail ArgumentError, 'Too many arguments' if args.size > 2
+
+      if args.empty?
+        [Session.current!, true]
+      else
+        result = args.dup
+        if result.size == 1
+          result << ([true, false].include?(args[0]) ? Session.current! : true)
+        end
 
-      puts "Java Exception in a transaction, cause: #{exception.cause}"
-      exception.cause.print_stack_trace
+        [true, false].include?(result[0]) ? result.reverse : result
+      end
     end
 
-    # @private
-    def unregister(tx)
-      Thread.current[:neo4j_curr_tx] = nil if tx == Thread.current[:neo4j_curr_tx]
+    def current_for(session)
+      stack_for(session).first
     end
 
-    # @private
-    def register(tx)
-      # we don't support running more then one transaction per thread
-      fail 'Already running a transaction' if current
-      Thread.current[:neo4j_curr_tx] = tx
+    def stack_for(session)
+      TransactionsRegistry.transactions_by_session_id ||= {}
+      TransactionsRegistry.transactions_by_session_id[session.object_id] ||= []
     end
 
-    # @private
-    def unregister_current
-      Thread.current[:neo4j_curr_tx] = nil
+    private
+
+    def print_exception_cause(exception)
+      return if !exception.respond_to?(:cause) || !exception.cause.respond_to?(:print_stack_trace)
+
+      Core.logger.info "Java Exception in a transaction, cause: #{exception.cause}"
+      exception.cause.print_stack_trace
     end
   end
 end