activegraph 11.1.0.beta.1 → 11.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4aade7db7557b1222b78e048550606354b0707a60c9375359a4f945b702763c2
-  data.tar.gz: a22b396cdc491118ecbaf947ac9e00d9ea088fe0df5afa51a3a38b7f085db9ff
+  metadata.gz: 4b0ec846225c753d7a2dc2bc3923c95f52dec582324559df182f23df633f564c
+  data.tar.gz: 1205c8eaf374112629a173f55e2c9a5fae42324073b2f540815eb984cb87e324
 SHA512:
-  metadata.gz: 663bc1323338cc7261cb2281b5ad6a86d794baed1fd2dc82a08f8d1b5eae593a151927529330425d8ffdc71adb17e8a7c70aa3872c63641cd2d77dcfe46016cc
-  data.tar.gz: c894eff95679b5982e418dccff5deb160ff41a46e661bee2f8278b230ab59fe20befc8aed83b8144dd112485df98d61c6fa1f60d226f63a1df3db6cd34b4a9a4
+  metadata.gz: '07091d4bf26b0b2bfb4d6313668e358eb78f8eb6afb7244063a2293a3596963687debf7fe6e72177ba388ac008a9452a8bd580fb48064575354e0e208765f475'
+  data.tar.gz: '09dc2f6eaf0126d26b76aba057b9b7e77e0b633f0b13ab99964ed64fd64e7421f22eaa470d9abd0fca4bd896e122ca938814683bc0c618e7d37d2ded400c00de'

data/CHANGELOG.md

@@ -3,6 +3,25 @@ All notable changes to this project will be documented in this file.
 This file should follow the standards specified on [http://keepachangelog.com/]
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [11.2.0] 2023-02-06
+
+## Added
+
+- support for neo4j:schema:dump and :load for neo4j 4 and 5. No automatic migration of schema on major neo4j upgrades. Schema must be regenerated with neo4j:schema:dump or manually adjusted to new syntax on those upgrades.
+  
+## [11.1.0] 2023-01-10
+
+## Added
+
+- support for pure ruby driver, neo4j-ruby-driver 4.4
+- support for neo4j 5
+
+## Fixed
+
+- moved migrations into their own transactions
+- Uniqueness within a scope defined by a proc
+- Fixed lost @rel_var when branching QueryProxy
+
 ## [11.0.2] 2021-11-05
 
 ## Fixed

data/README.md

@@ -45,21 +45,22 @@ Neo4j.rb v4.1.0 was released in January of 2015. Its changes are outlined [here]
 
 ## Neo4j version support
 
-| **Neo4j Version** | v2.x | v3.x  | >= v4.x | >= 7.0.3 | activegraph 10   | activegraph 11 (jRuby only) |
-|-------------------|------|-------|---------|----------|------------------|-----------------------------|
-| 1.9.x             | Yes  | No    | No      | No       | No               | No
-| 2.0.x             | No   | Yes   | No      | No       | No               | No
-| 2.1.x             | No   | Yes   | Yes *   | Yes      | No               | No
-| 2.2.x             | No   | No    | Yes     | Yes      | No               | No
-| 2.3.x             | No   | No    | Yes     | Yes      | No               | No
-| 3.0, 3.1, 3.3     | No   | No    | No      | Yes      | No               | No
-| 3.4               | No   | No    | No      | Yes      | Yes              | No
-| 3.5               | No   | No    | No      | Yes      | Yes              | Yes
-| 4.0               | No   | No    | No      | No       | Yes              | Yes
-| 4.1               | No   | No    | No      | No       | No               | Yes
-| 4.2               | No   | No    | No      | No       | No               | Yes
-| 4.3               | No   | No    | No      | No       | No               | Yes
-| 4.4               | No   | No    | No      | No       | No               | Yes
+| **Neo4j Version** | v2.x | v3.x  | >= v4.x | >= 7.0.3 | activegraph 10   | activegraph 11.1 |
+|-------------------|------|-------|---------|----------|------------------|------------------|
+| 1.9.x             | Yes  | No    | No      | No       | No               | No               
+| 2.0.x             | No   | Yes   | No      | No       | No               | No               
+| 2.1.x             | No   | Yes   | Yes *   | Yes      | No               | No               
+| 2.2.x             | No   | No    | Yes     | Yes      | No               | No               
+| 2.3.x             | No   | No    | Yes     | Yes      | No               | No               
+| 3.0, 3.1, 3.3     | No   | No    | No      | Yes      | No               | No               
+| 3.4               | No   | No    | No      | Yes      | Yes              | No               
+| 3.5               | No   | No    | No      | Yes      | Yes              | Yes              
+| 4.0               | No   | No    | No      | No       | Yes              | Yes              
+| 4.1               | No   | No    | No      | No       | No               | Yes              
+| 4.2               | No   | No    | No      | No       | No               | Yes              
+| 4.3               | No   | No    | No      | No       | No               | Yes              
+| 4.4               | No   | No    | No      | No       | No               | Yes              
+| 5.x               | No   | No    | No      | No       | No               | Yes              
 
 `*` Neo4j.rb >= 4.x doesn't support Neo4j versions before 2.1.5.  To use 2.1.x you should upgrade to a version >= 2.1.5
 

data/activegraph.gemspec

@@ -33,7 +33,7 @@ DESCRIPTION
   s.add_dependency('activemodel', '>= 4.0')
   s.add_dependency('activesupport', '>= 4.0')
   s.add_dependency('i18n', '!= 1.8.8') # https://github.com/jruby/jruby/issues/6547
-  s.add_dependency('neo4j-ruby-driver', '>= 4.4.0.alpha.7')
+  s.add_dependency('neo4j-ruby-driver', '>= 4.4.1')
   s.add_dependency('orm_adapter', '~> 0.5.0')
   s.add_dependency('sorted_set')
   s.add_development_dependency('guard')

data/lib/active_graph/core/label.rb

@@ -2,20 +2,33 @@ module ActiveGraph
   module Core
     class Label
       attr_reader :name
+      delegate :version?, to: ActiveGraph::Base
 
       def initialize(name)
         @name = name
       end
 
-      def create_index(property, options = {})
+      def create_index(*properties, **options)
         validate_index_options!(options)
-        properties = property.is_a?(Array) ? property.join(',') : property
-        schema_query("CREATE INDEX ON :`#{@name}`(#{properties})")
+        if version?('>=4.4')
+          properties = properties.map { |p| "l.#{p}" }
+          fragment = "FOR (l:`#{@name}`) ON"
+        else
+          fragment = "ON :`#{@name}`"
+        end
+        schema_query("CREATE INDEX #{fragment} (#{properties.join('.')})")
       end
 
       def drop_index(property, options = {})
         validate_index_options!(options)
-        schema_query("DROP INDEX ON :`#{@name}`(#{property})")
+        if version?('<4.3')
+          schema_query("DROP INDEX ON :`#{@name}`(#{property})")
+        else
+          schema_query("SHOW INDEXES YIELD * WHERE labelsOrTypes = $labels AND properties = $properties",
+                       labels: [@name], properties: [property]).each do |record|
+            schema_query("DROP INDEX #{record[:name]}")
+          end
+        end
       end
 
       # Creates a neo4j constraint on a property
@@ -27,7 +40,8 @@ module ActiveGraph
       def create_constraint(property, constraints)
         cypher = case constraints[:type]
                  when :unique, :uniqueness
-                   "CREATE CONSTRAINT ON (n:`#{name}`) ASSERT n.`#{property}` IS UNIQUE"
+                   _for, _require = version?('>=4.4') ? %w[FOR REQUIRE] : %w[ON ASSERT]
+                   "CREATE CONSTRAINT #{_for} (n:`#{name}`) #{_require} n.`#{property}` IS UNIQUE"
                  else
                    fail "Not supported constraint #{constraints.inspect} for property #{property} (expected :type => :unique)"
                  end
@@ -46,15 +60,20 @@ module ActiveGraph
       #   label.drop_constraint(:name, {type: :unique})
       #
       def drop_constraint(property, constraint)
-        cypher = case constraint[:type]
-                 when :unique, :uniqueness
-                   "n.`#{property}` IS UNIQUE"
-                 when :exists
-                   "exists(n.`#{property}`)"
-                 else
-                   fail "Not supported constraint #{constraint.inspect}"
-                 end
-        schema_query("DROP CONSTRAINT ON (n:`#{name}`) ASSERT #{cypher}")
+        return drop_constraint42(property, constraint) if version?('<4.3')
+        type = case constraint[:type]
+               when :unique, :uniqueness
+                 'UNIQUENESS'
+               when :exists
+                 'NODE_PROPERTY_EXISTENCE'
+               else
+                 fail "Not supported constraint #{constraint.inspect}"
+               end
+        schema_query(
+          'SHOW CONSTRAINTS YIELD * WHERE type = $type AND labelsOrTypes = $labels AND properties = $properties',
+          type: type, labels: [name], properties: [property]).first[:name].tap do |constraint_name|
+          schema_query("DROP CONSTRAINT #{constraint_name}")
+        end
       end
 
       def drop_uniqueness_constraint(property, options = {})
@@ -105,7 +124,12 @@ module ActiveGraph
         def drop_indexes
           indexes.each do |definition|
             begin
-              ActiveGraph::Base.query("DROP INDEX ON :`#{definition[:label]}`(#{definition[:properties][0]})")
+              ActiveGraph::Base.query(
+                if definition[:name]
+                  "DROP INDEX #{definition[:name]}"
+                else
+                  "DROP INDEX ON :`#{definition[:label]}`(#{definition[:properties][0]})"
+                end)
             rescue Neo4j::Driver::Exceptions::DatabaseException
               # This will error on each constraint. Ignore and continue.
               next
@@ -114,7 +138,9 @@ module ActiveGraph
         end
 
         def drop_constraints
-          result = ActiveGraph::Base.read_transaction { |tx| tx.run('CALL db.constraints').to_a }
+          result = ActiveGraph::Base.read_transaction do |tx|
+            tx.run(ActiveGraph::Base.version?('<4.3') ? 'CALL db.constraints' : 'SHOW CONSTRAINTS YIELD *').to_a
+          end
           ActiveGraph::Base.write_transaction do |tx|
             result.each do |record|
               tx.run("DROP #{record.keys.include?(:name) ? "CONSTRAINT #{record[:name]}" : record[:description]}")
@@ -123,14 +149,26 @@ module ActiveGraph
         end
       end
 
-      def schema_query(cypher)
-        ActiveGraph::Base.query(cypher, {})
+      def schema_query(cypher, **params)
+        ActiveGraph::Base.query(cypher, params)
       end
 
       def validate_index_options!(options)
         return unless options[:type] && options[:type] != :exact
         fail "Type #{options[:type]} is not supported"
       end
+
+      def drop_constraint42(property, constraint)
+        cypher = case constraint[:type]
+                 when :unique, :uniqueness
+                   "n.`#{property}` IS UNIQUE"
+                 when :exists
+                   "exists(n.`#{property}`)"
+                 else
+                   fail "Not supported constraint #{constraint.inspect}"
+                 end
+        schema_query("DROP CONSTRAINT ON (n:`#{name}`) ASSERT #{cypher}")
+      end
     end
   end
 end

data/lib/active_graph/core/schema.rb

@@ -1,63 +1,92 @@
 module ActiveGraph
   module Core
     module Schema
+      FILTER = {
+        3 => [:type, 'node_unique_property'],
+        4 => [:uniqueness, 'UNIQUE'],
+      }
+
       def version
-        read_transaction do
+        @version ||= read_transaction do
           # BTW: community / enterprise could be retrieved via `result.first.edition`
           query('CALL dbms.components()', {}, skip_instrumentation: true).first[:versions][0]
+            .then(&Gem::Version.method(:new))
         end
       end
 
+      def version?(requirement)
+        Gem::Requirement.create(requirement).satisfied_by?(Gem::Version.new(version))
+      end
+
       def indexes
-        raw_indexes do |keys, result|
-          result.map do |row|
-            { type: row[:type].to_sym, label: label(keys, row), properties: properties(row),
-              state: row[:state].to_sym }
-          end
+        normalize(raw_indexes, *%i[type state])
+      end
+
+      def normalize(result, *extra)
+        result.map do |row|
+          definition(row, version?('<4') ? :index_cypher_v3 : :index_cypher)
+            .merge(extra.to_h { |key| [key, row[key].to_sym] })
         end
       end
 
       def constraints
-        raw_indexes do |keys, result|
-          result.select(&method(v4?(keys) ? :v4_filter : :v3_filter)).map do |row|
-            { type: :uniqueness, label: label(keys, row), properties: properties(row) }
-          end
+        if version?('<4.3')
+          raw_indexes.select(&method(:constraint_owned?))
+        else
+          raw_constraints.select(&method(:constraint_filter))
+        end.map { |row| definition(row, :constraint_cypher).merge(type: :uniqueness) }
+      end
+
+      private def raw_constraints
+        read_transaction do
+          query('SHOW CONSTRAINTS YIELD *', {}, skip_instrumentation: true).to_a
         end
       end
 
       def raw_indexes
         read_transaction do
-          result = query('CALL db.indexes()', {}, skip_instrumentation: true)
-          yield result.keys, result.reject { |row| row[:type] == 'LOOKUP' }
+          query(version?('<4.3') ? 'CALL db.indexes()' : 'SHOW INDEXES YIELD *', {}, skip_instrumentation: true)
+            .reject { |row| row[:type] == 'LOOKUP' }
         end
       end
 
+      def constraint_owned?(record)
+        FILTER[major]&.then { |(key, value)| record[key] == value } || record[:owningConstraint]
+      end
+
       private
 
-      def v4_filter(row)
-        row[:uniqueness] == 'UNIQUE'
+      def major
+        @major ||= version.segments.first
       end
 
-      def v3_filter(row)
-        row[:type] == 'node_unique_property'
+      def constraint_filter(record)
+        %w[UNIQUENESS RELATIONSHIP_PROPERTY_EXISTENCE NODE_PROPERTY_EXISTENCE NODE_KEY].include?(record[:type])
       end
 
-      def label(keys, row)
-        if v34?(keys)
-          row[:label]
-        else
-          (v4?(keys) ? row[:labelsOrTypes] : row[:tokenNames]).first
-        end.to_sym
+      def index_cypher_v3(label, properties)
+        "INDEX ON :#{label}#{com_sep(properties, nil)}"
+      end
+
+      def index_cypher(label, properties)
+        "INDEX FOR (n:#{label}) ON #{com_sep(properties)}"
+      end
+
+      def constraint_cypher(label, properties)
+        "CONSTRAINT ON (n:#{label}) ASSERT #{com_sep(properties)} IS UNIQUE"
+      end
+
+      def com_sep(properties, prefix = 'n.')
+        "(#{properties.map { |prop| "#{prefix}#{prop}" }.join(', ')})"
       end
 
-      def v4?(keys)
-        return @v4 unless @v4.nil?
-        @v4 = keys.include?(:labelsOrTypes)
+      def definition(row, template)
+        { label: label(row), properties: properties(row), name: row[:name],
+          create_statement: row[:createStatement] || send(template,label(row), row[:properties]) }
       end
 
-      def v34?(keys)
-        return @v34 unless @v34.nil?
-        @v34 = keys.include?(:label)
+      def label(row)
+        row[version?('>=4') ? :labelsOrTypes : :tokenNames].first.to_sym
       end
 
       def properties(row)

data/lib/active_graph/core.rb

@@ -5,7 +5,7 @@ require 'active_graph/core/query'
 require 'active_graph/core/record'
 require 'active_graph/core/wrappable'
 require 'active_graph/transaction'
-require 'neo4j_ruby_driver'
+require 'neo4j/driver'
 
 Neo4j::Driver::Types::Entity.include ActiveGraph::Core::Wrappable
 Neo4j::Driver::Types::Entity.prepend ActiveGraph::Core::Entity

data/lib/active_graph/migrations/helpers/id_property.rb

@@ -23,12 +23,12 @@ module ActiveGraph
         protected
 
         def idless_count(label, id_property)
-          query.match(n: label).where("NOT EXISTS(n.#{id_property})").pluck('COUNT(n) AS ids').first
+          query.match(n: label).where("n.#{id_property} IS NULL").pluck('COUNT(n) AS ids').first
         end
 
         def id_batch_set(label, id_property, new_ids, count)
           ActiveGraph::Base.transaction do
-            execute("MATCH (n:`#{label}`) WHERE NOT EXISTS(n.#{id_property})
+            execute("MATCH (n:`#{label}`) WHERE n.#{id_property} IS NULL
             with COLLECT(n) as nodes, #{new_ids} as ids
             FOREACH(i in range(0,#{count - 1})|
               FOREACH(node in [nodes[i]]|

data/lib/active_graph/migrations/helpers.rb

@@ -83,7 +83,7 @@ module ActiveGraph
       private
 
       def property_exists?(label, property)
-        by_label(label).where("EXISTS(n.#{property})").return(:n).any?
+        by_label(label).where("n.#{property} IS NOT NULL").return(:n).any?
       end
 
       def by_label(label, options = {})

data/lib/active_graph/migrations/schema.rb

@@ -3,15 +3,15 @@ module ActiveGraph
     module Schema
       class << self
         def fetch_schema_data
-          { constraints: fetch_constraint_descriptions.sort, indexes: fetch_index_descriptions.sort }
+          %i[constraints indexes].to_h { |schema_elem| [schema_elem, send("fetch_#{schema_elem}_descriptions").keys] }
         end
 
         def synchronize_schema_data(schema_data, remove_missing)
-          queries = []
-          ActiveGraph::Base.read_transaction do
-            queries += drop_and_create_queries(fetch_constraint_descriptions, schema_data[:constraints], remove_missing)
-            queries += drop_and_create_queries(fetch_index_descriptions, schema_data[:indexes], remove_missing)
-          end
+          queries =
+            ActiveGraph::Base.read_transaction do
+              drop_and_create_queries(fetch_constraints_descriptions, schema_data[:constraints], 'CONSTRAINT', remove_missing) +
+                drop_and_create_queries(fetch_indexes_descriptions, schema_data[:indexes], 'INDEX', remove_missing)
+            end
           ActiveGraph::Base.write_transaction do
             queries.each(&ActiveGraph::Base.method(:query))
           end
@@ -19,46 +19,30 @@ module ActiveGraph
 
         private
 
-        def fetch_constraint_descriptions
-          ActiveGraph::Base.query('CALL db.constraints() YIELD description').map(&:first)
+        def fetch_indexes_descriptions
+            ActiveGraph::Base.raw_indexes.reject(&ActiveGraph::Base.method(:constraint_owned?))
+                             .then(&ActiveGraph::Base.method(:normalize)).then(&method(:fetch_descriptions))
         end
 
-        def fetch_index_descriptions
-          ActiveGraph::Base.raw_indexes do |keys, result|
-            if keys.include?(:description)
-              v3_indexes(result)
-            else
-              v4_indexes(result)
-            end
-          end
+        def fetch_constraints_descriptions
+          fetch_descriptions(ActiveGraph::Base.constraints)
         end
 
-        def v3_indexes(result)
-          result.reject do |row|
-            # These indexes are created automagically when the corresponding constraints are created
-            row[:type] == 'node_unique_property'
-          end.map { |row| row[:description] }
+        def fetch_descriptions(results)
+          results.map { |definition| definition.values_at(:create_statement, :name) }.sort.to_h
         end
 
-        def v4_indexes(result)
-          result.reject do |row|
-            # These indexes are created automagically when the corresponding constraints are created
-            row[:uniqueness] == 'UNIQUE'
-          end.map(&method(:description))
+        def drop_and_create_queries(existing, specified, schema_elem, remove_missing)
+          (remove_missing ? existing.except(*specified).map { |stmt, name| drop_statement(schema_elem, stmt, name) } : []) +
+            (specified - existing.keys).map(&method(:create_statement))
         end
 
-        def description(row)
-          "INDEX FOR (n:#{row[:labelsOrTypes].first}) ON (#{row[:properties].map { |prop| "n.#{prop}" }.join(', ')})"
+        def drop_statement(schema_elem, create_statement, name)
+          "DROP #{name&.then { |name| "#{schema_elem} #{name}" } || create_statement}"
         end
 
-        def drop_and_create_queries(existing, specified, remove_missing)
-          [].tap do |queries|
-            if remove_missing
-              (existing - specified).each { |description| queries << "DROP #{description}" }
-            end
-
-            (specified - existing).each { |description| queries << "CREATE #{description}" }
-          end
+        def create_statement(stmt)
+          stmt.start_with?('CREATE ') ? stmt : "CREATE #{stmt}"
         end
       end
     end

data/lib/active_graph/version.rb

@@ -1,3 +1,3 @@
 module ActiveGraph
-  VERSION = '11.1.0.beta.1'
+  VERSION = '11.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activegraph
 version: !ruby/object:Gem::Version
-  version: 11.1.0.beta.1
+  version: 11.2.0
 platform: ruby
 authors:
 - Andreas Ronge, Brian Underwood, Chris Grigg, Heinrich Klobuczek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-23 00:00:00.000000000 Z
+date: 2023-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.4.0.alpha.7
+        version: 4.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.4.0.alpha.7
+        version: 4.4.1
 - !ruby/object:Gem::Dependency
   name: orm_adapter
   requirement: !ruby/object:Gem::Requirement
@@ -440,11 +440,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: A graph database for Ruby