activegraph 10.0.0.pre.alpha.6 → 10.0.0.pre.alpha.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '080320681eddb19c4c347525bd2aa1eb29c570084d341c6ec6ee4b66f1ab8480'
-  data.tar.gz: edcfccffbedcd4c49504fb86241574d26e6c737b0ab12dac30947b99c792c4d1
+  metadata.gz: 2ee929286df7c03716620060ba6229dae865612f295c02e02872a8a1fa329c7f
+  data.tar.gz: 7d3983fc31041476a7cc6e0b92119b6c1e6ad1207ae5d1e6293871a92f9f865a
 SHA512:
-  metadata.gz: 61fe3eb22783d399afd333bce3770621758162bbae701f3a6127c594b0268984899594a228c531bff717059390a57412eb92527bdae38312331b6a68a6be1479
-  data.tar.gz: dfd1debd983d0e65e223d0a4c15779d39e3be8611aadc975f75298a90063fa735f7be248d79694694b06d8f66b2612f5478420d8d98ef7fd384d056632cadd70
+  metadata.gz: 582aedd1880e79fb5983774d2fea5456b247f8c72b57caa676de5b5272766f4e7db44c6de927c3899a23a5bc38a92ef4b71bffc782ba44facf9086d818ca9c58
+  data.tar.gz: 982dc47105a57220e1b1e09a1fb3ed18b47646dd9c7166cef754a30609e12f0487722b411b7efef2dcacc3fa5bb7ac149028b8ccb3d3c8abca4cb1b93f501d32

data/lib/neo4j/active_base.rb

@@ -25,7 +25,7 @@ module Neo4j
       def new_driver(url, options = {})
         verbose_query_logs = Neo4j::Config.fetch(:verbose_query_logs, false)
         Neo4j::Core::Driver
-          .new(url, options.merge(verbose_query_logs: verbose_query_logs))
+          .new(url, options, verbose_query_logs: verbose_query_logs)
       end
 
       def transaction

data/lib/neo4j/active_node/dependent/query_proxy_methods.rb

@@ -42,7 +42,7 @@ module Neo4j
                .with(other_node)
                .match("()#{association.arrow_cypher(:orphan_rel)}(#{other_node})")
                .with(other_node, count: 'count(*)')
-               .where('count = {one}', one: 1)
+               .where('count = $one', one: 1)
                .break
         end
       end

data/lib/neo4j/active_node/persistence.rb

@@ -66,7 +66,7 @@ module Neo4j::ActiveNode
     # @param [Array] labels The labels to use for creating the new node.
     # @return [Neo4j::Node] A CypherNode or EmbeddedNode
     def _create_node(node_props, labels = labels_for_create)
-      query = "CREATE (n:`#{Array(labels).join('`:`')}`) SET n = {props} RETURN n"
+      query = "CREATE (n:`#{Array(labels).join('`:`')}`) SET n = $props RETURN n"
       neo4j_query(query, {props: node_props}, wrap_level: :core_entity).to_a[0].n
     end
 

data/lib/neo4j/active_node/query.rb

@@ -23,7 +23,7 @@ module Neo4j
       # This method does not exist within QueryProxy and can only be used to start a new chain.
       #
       # @example Start a new QueryProxy chain with the first identifier set manually
-      #   # Generates: MATCH (s:`Student`), (l:`Lesson`), s-[rel1:`ENROLLED_IN`]->(l:`Lesson`) WHERE ID(s) = {neo_id_17963}
+      #   # Generates: MATCH (s:`Student`), (l:`Lesson`), s-[rel1:`ENROLLED_IN`]->(l:`Lesson`) WHERE ID(s) = $neo_id_17963
       #   student.as(:s).lessons(:l)
       #
       # @param [String, Symbol] node_var The identifier to use within the QueryProxy object

data/lib/neo4j/active_node/query/query_proxy_methods.rb

@@ -88,9 +88,9 @@ module Neo4j
         def include?(other, target = nil)
           query_with_target(target) do |var|
             where_filter = if other.respond_to?(:neo_id) || association_id_key == :neo_id
-                             "ID(#{var}) = {other_node_id}"
+                             "ID(#{var}) = $other_node_id"
                            else
-                             "#{var}.#{association_id_key} = {other_node_id}"
+                             "#{var}.#{association_id_key} = $other_node_id"
                            end
             node_id = other.respond_to?(:neo_id) ? other.neo_id : other
             self.where(where_filter).params(other_node_id: node_id).query.reorder.return("count(#{var}) as count").first.count > 0
@@ -287,7 +287,7 @@ module Neo4j
         def exists_query_start(condition, target)
           case condition
           when Integer
-            self.where("ID(#{target}) = {exists_condition}").params(exists_condition: condition)
+            self.where("ID(#{target}) = $exists_condition").params(exists_condition: condition)
           when Hash
             self.where(condition.keys.first => condition.values.first)
           when String

data/lib/neo4j/core/driver.rb

@@ -21,7 +21,7 @@ module Neo4j
       end
 
       class << self
-        def new_instance(url)
+        def new_instance(url, options = {})
           uri = URI(url)
           user = uri.user
           password = uri.password
@@ -30,14 +30,14 @@ module Neo4j
                        else
                          Neo4j::Driver::AuthTokens.none
                        end
-          Neo4j::Driver::GraphDatabase.driver(url, auth_token)
+          Neo4j::Driver::GraphDatabase.driver(url, auth_token, options)
         end
       end
 
-      def initialize(url, options = {})
+      def initialize(url, options = {}, extended_options = {})
         self.url = url
-        @driver = self.class.new_instance(url)
-        @options = options
+        @driver = self.class.new_instance(url, options.merge(encryption: false))
+        @options = extended_options
       end
 
       def logger

data/lib/neo4j/core/label.rb

@@ -48,11 +48,13 @@ module Neo4j
       def drop_constraint(property, constraint)
         cypher = case constraint[:type]
                  when :unique, :uniqueness
-                   "DROP CONSTRAINT ON (n:`#{name}`) ASSERT n.`#{property}` IS UNIQUE"
+                   "n.`#{property}` IS UNIQUE"
+                 when :exists
+                   "exists(n.`#{property}`)"
                  else
                    fail "Not supported constraint #{constraint.inspect}"
                  end
-        schema_query(cypher)
+        schema_query("DROP CONSTRAINT ON (n:`#{name}`) ASSERT #{cypher}")
       end
 
       def drop_uniqueness_constraint(property, options = {})
@@ -65,25 +67,10 @@ module Neo4j
         end
       end
 
-      def self.indexes
-        Neo4j::Transaction.indexes
-      end
-
       def drop_indexes
         self.class.drop_indexes
       end
 
-      def self.drop_indexes
-        indexes.each do |definition|
-          begin
-            Neo4j::Transaction.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
@@ -100,16 +87,6 @@ module Neo4j
         end
       end
 
-      def drop_uniqueness_constraints
-        self.class.drop_uniqueness_constraints
-      end
-
-      def self.drop_uniqueness_constraints
-        Neo4j::Transaction.constraints.each do |definition|
-          Neo4j::Transaction.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
@@ -118,11 +95,6 @@ module Neo4j
         uniqueness_constraints.include?([property])
       end
 
-      def self.wait_for_schema_changes
-        schema_threads.map(&:join)
-        set_schema_threads(session, [])
-      end
-
       private
 
       # Store schema threads on the session so that we can easily wait for all
@@ -136,6 +108,35 @@ module Neo4j
       end
 
       class << self
+        def indexes
+          Neo4j::Transaction.indexes
+        end
+
+        def drop_indexes
+          indexes.each do |definition|
+            begin
+              Neo4j::Transaction.query("DROP INDEX ON :`#{definition[:label]}`(#{definition[:properties][0]})")
+            rescue Neo4j::Driver::Exceptions::DatabaseException
+              # This will error on each constraint. Ignore and continue.
+              next
+            end
+          end
+        end
+
+        def drop_constraints
+          Neo4j::Transaction.named_constraints.each do |constraint|
+            Neo4j::Transaction.query("DROP CONSTRAINT #{constraint.name}")
+          end
+          Neo4j::Transaction.constraints.each do |definition|
+            Neo4j::Transaction.query("DROP CONSTRAINT ON (n:`#{definition[:label]}`) ASSERT n.`#{definition[:properties][0]}` IS UNIQUE")
+          end
+        end
+
+        def wait_for_schema_changes
+          schema_threads.map(&:join)
+          set_schema_threads(session, [])
+        end
+
         def schema_threads
           Neo4j::Transaction.instance_variable_get('@_schema_threads') || []
         end

data/lib/neo4j/core/query.rb

@@ -216,10 +216,10 @@ module Neo4j
 
       # Allows for the specification of values for params specified in query
       # @example
-      #   # Creates a query representing the cypher: MATCH (q: Person {id: {id}})
+      #   # Creates a query representing the cypher: MATCH (q: Person {id: $id})
       #   # Calls to params don't affect the cypher query generated, but the params will be
       #   # Passed down when the query is made
-      #   Query.new.match('(q: Person {id: {id}})').params(id: 12)
+      #   Query.new.match('(q: Person {id: $id})').params(id: 12)
       #
       def params(args)
         copy.tap { |new_query| new_query.instance_variable_get('@params'.freeze).add_params(args) }

data/lib/neo4j/core/query_clauses.rb

@@ -188,13 +188,13 @@ module Neo4j
 
             param = add_param(param, value)
 
-            "#{key} #{array_value?(value, is_set) ? 'IN' : '='} {#{param}}"
+            "#{key} #{array_value?(value, is_set) ? 'IN' : '='} $#{param}"
           end
         end
 
         def range_key_value_string(key, value, previous_keys, param)
           begin_param, end_param = add_params("#{param}_range_min" => value.begin, "#{param}_range_max" => value.end)
-          "#{key} >= {#{begin_param}} AND #{previous_keys[-2]}.#{key} <#{'=' unless value.exclude_end?} {#{end_param}}"
+          "#{key} >= $#{begin_param} AND #{previous_keys[-2]}.#{key} <#{'=' unless value.exclude_end?} $#{end_param}"
         end
 
         def array_value?(value, is_set)
@@ -221,7 +221,7 @@ module Neo4j
             else
               param_key = "#{prefix}#{key}".gsub(/:+/, '_')
               param_key = add_param(param_key, value)
-              "#{key}: {#{param_key}}"
+              "#{key}: $#{param_key}"
             end
           end.join(Clause::COMMA_SPACE)
 
@@ -306,7 +306,7 @@ module Neo4j
 
           param = add_param(param, pattern)
 
-          "#{key} =~ {#{param}}"
+          "#{key} =~ $#{param}"
         end
 
         class << self
@@ -320,7 +320,7 @@ module Neo4j
                 params.add_params(params_arg)
               else
                 param_var = params.add_params(question_mark_param: params_arg)[0]
-                query_string = query_string.gsub(ARG_HAS_QUESTION_MARK_REGEX, "\\1{#{param_var}}\\2")
+                query_string = query_string.gsub(ARG_HAS_QUESTION_MARK_REGEX, "\\1$#{param_var}\\2")
               end
 
               [from_arg(query_string, params, options)]
@@ -456,7 +456,7 @@ module Neo4j
       end
 
       class CreateUniqueClause < CreateClause
-        KEYWORD = 'CREATE UNIQUE'
+        KEYWORD = 'MERGE'
       end
 
       class MergeClause < CreateClause
@@ -536,7 +536,7 @@ module Neo4j
         def from_string(value)
           param_var = "#{self.class.keyword_downcase}_#{value}"
           param_var = add_param(param_var, value.to_i)
-          "{#{param_var}}"
+          "$#{param_var}"
         end
 
         def from_integer(value)
@@ -566,13 +566,13 @@ module Neo4j
         def from_string(value)
           clause_id = "#{self.class.keyword_downcase}_#{value}"
           clause_id = add_param(clause_id, value.to_i)
-          "{#{clause_id}}"
+          "$#{clause_id}"
         end
 
         def from_integer(value)
           clause_id = "#{self.class.keyword_downcase}_#{value}"
           clause_id = add_param(clause_id, value)
-          "{#{clause_id}}"
+          "$#{clause_id}"
         end
 
         class << self
@@ -597,7 +597,7 @@ module Neo4j
           when Hash
             if @options[:set_props]
               param = add_param("#{key}_set_props", value)
-              "#{key} = {#{param}}"
+              "#{key} = $#{param}"
             else
               value.map { |k, v| key_value_string("#{key}.`#{k}`", v, ['setter'], true) }
             end

data/lib/neo4j/core/query_find_in_batches.rb

@@ -19,7 +19,7 @@ module Neo4j
           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}")
+          records = query.where("#{primary_key_var} > $primary_key_offset")
                          .params(primary_key_offset: primary_key_offset).to_a
         end
       end

data/lib/neo4j/core/schema.rb

@@ -12,19 +12,50 @@ module Neo4j
         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 }
+          { type: row.type.to_sym, label: label(result, row), properties: properties(row), 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] }
+        result.select(&method(v4?(result) ? :v4_filter : :v3_filter)).map do |row|
+          { type: :uniqueness, label: label(result, row), properties: properties(row) }
         end
       end
+
+      def named_constraints
+        result = query('CALL db.constraints()', {}, skip_instrumentation: true)
+        result.columns.include?(:name) ? result : []
+      end
+
+      private
+
+      def v4_filter(row)
+        row.uniqueness == 'UNIQUE'
+      end
+
+      def v3_filter(row)
+        row.type == 'node_unique_property'
+      end
+
+      def label(result, row)
+        (v34?(result) ? row.label : (v4?(result) ? row.labelsOrTypes : row.tokenNames).first).to_sym
+      end
+
+      def v4?(result)
+        return @v4 unless @v4.nil?
+        @v4 = result.columns.include?(:labelsOrTypes)
+      end
+
+      def v34?(result)
+        return @v34 unless @v34.nil?
+        @v34 = result.columns.include?(:label)
+      end
+
+      def properties(row)
+        row.properties.map(&:to_sym)
+      end
     end
   end
 end

data/lib/neo4j/migrations/helpers/schema.rb

@@ -10,14 +10,26 @@ module Neo4j
           force = options[:force] || false
           type = options[:type] || :uniqueness
           label_object = ActiveBase.label_object(label)
-          fail_duplicate_constraint_or_index!(:constraint, label, property) if !force && label_object.constraint?(property)
+          if label_object.constraint?(property)
+            if force
+              label_object.drop_constraint(property, type: type)
+            else
+              fail_duplicate_constraint_or_index!(:constraint, label, property)
+            end
+          end
           label_object.create_constraint(property, type: type)
         end
 
         def add_index(label, property, options = {})
           force = options[:force] || false
           label_object = ActiveBase.label_object(label)
-          fail_duplicate_constraint_or_index!(:index, label, property) if !force && label_object.index?(property)
+          if label_object.index?(property)
+            if force
+              label_object.drop_index(property)
+            else
+              fail_duplicate_constraint_or_index!(:index, label, property)
+            end
+          end
           label_object.create_index(property)
         end
 

data/lib/neo4j/railtie.rb

@@ -70,7 +70,7 @@ module Neo4j
     end
 
     def default_session_path_or_url
-      ENV['NEO4J_URL'] || ENV['NEO4J_PATH'] || 'http://localhost:7474'
+      ENV['NEO4J_URL'] || ENV['NEO4J_PATH'] || 'bolt://localhost:7474'
     end
 
     def yaml_config_data

data/lib/neo4j/shared/persistence.rb

@@ -237,7 +237,7 @@ module Neo4j::Shared
 
     def increment_by_query!(match_query, attribute, by, element_name = :n)
       new_attribute = match_query.with(element_name)
-                                 .set("#{element_name}.`#{attribute}` = COALESCE(#{element_name}.`#{attribute}`, 0) + {by}")
+                                 .set("#{element_name}.`#{attribute}` = COALESCE(#{element_name}.`#{attribute}`, 0) + $by")
                                  .params(by: by).limit(1)
                                  .pluck("#{element_name}.`#{attribute}`").first
       return false unless new_attribute

data/lib/neo4j/shared/query_factory.rb

@@ -47,7 +47,7 @@ module Neo4j::Shared
 
     def match_query
       base_query
-        .match(match_string).where("ID(#{identifier}) = {#{identifier_id}}")
+        .match(match_string).where("ID(#{identifier}) = $#{identifier_id}")
         .params(identifier_id.to_sym => graph_object.neo_id)
     end
 
@@ -70,7 +70,7 @@ module Neo4j::Shared
     def create_query
       return match_query if graph_object.persisted?
       labels = graph_object.labels_for_create.map { |l| ":`#{l}`" }.join
-      base_query.create("(#{identifier}#{labels} {#{identifier}_params})").params(identifier_params => graph_object.props_for_create)
+      base_query.create("(#{identifier}#{labels} $#{identifier}_params)").params(identifier_params => graph_object.props_for_create)
     end
   end
 
@@ -84,9 +84,9 @@ module Neo4j::Shared
     def create_query
       return match_query if graph_object.persisted?
       create_props, set_props = filtered_props
-      base_query.send(graph_object.create_method, query_string).break
-                .set(identifier => set_props)
-                .params(:"#{identifier}_create_props" => create_props)
+      base_query.send(graph_object.create_method, query_string(create_props)).break
+        .set(identifier => set_props)
+        .params(params(create_props))
     end
 
     private
@@ -95,8 +95,28 @@ module Neo4j::Shared
       Neo4j::Shared::FilteredHash.new(graph_object.props_for_create, graph_object.creates_unique_option).filtered_base
     end
 
-    def query_string
-      "(#{graph_object.from_node_identifier})-[#{identifier}:`#{graph_object.type}` {#{identifier}_create_props}]->(#{graph_object.to_node_identifier})"
+    def query_string(create_props)
+      "(#{graph_object.from_node_identifier})-[#{identifier}:`#{graph_object.type}` #{pattern(create_props)}]->(#{graph_object.to_node_identifier})"
+    end
+
+    def params(create_props)
+      unique? ? create_props.transform_keys { |key| scoped(key).to_sym } : { namespace.to_sym => create_props }
+    end
+
+    def unique?
+      graph_object.create_method == :create_unique
+    end
+
+    def pattern(create_props)
+      unique? ? "{#{create_props.keys.map { |key| "#{key}: $#{scoped(key)}" }.join(', ')}}" : "$#{namespace}"
+    end
+
+    def scoped(key)
+      "#{namespace}_#{key}"
+    end
+
+    def namespace
+      "#{identifier}_create_props"
     end
   end
 end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = '10.0.0-alpha.6'
+  VERSION = '10.0.0-alpha.7'
 end

data/neo4j.gemspec

@@ -40,7 +40,7 @@ DESCRIPTION
   s.add_development_dependency('guard-rspec')
   s.add_development_dependency('guard-rubocop')
   s.add_development_dependency('neo4j-rake_tasks', '>= 0.3.0')
-  s.add_development_dependency("neo4j-#{RUBY_PLATFORM =~ /java/ ? 'java' : 'ruby'}-driver", '>= 0.1.10')
+  s.add_development_dependency("neo4j-#{RUBY_PLATFORM =~ /java/ ? 'java' : 'ruby'}-driver", '>= 0.3.0')
   s.add_development_dependency('os')
   s.add_development_dependency('pry')
   s.add_development_dependency('railties', '>= 4.0')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activegraph
 version: !ruby/object:Gem::Version
-  version: 10.0.0.pre.alpha.6
+  version: 10.0.0.pre.alpha.7
 platform: ruby
 authors:
 - Andreas Ronge, Brian Underwood, Chris Grigg, Heinrich Klobuczek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-26 00:00:00.000000000 Z
+date: 2020-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -128,14 +128,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.10
+        version: 0.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.10
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: os
   requirement: !ruby/object:Gem::Requirement
@@ -414,7 +414,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: A graph database for Ruby