neo4j 9.6.2 → 10.0.0.pre.alpha.1

data/lib/neo4j/core/query_builder.rb

@@ -0,0 +1,32 @@
+module Neo4j
+  module Core
+    class QueryBuilder
+      attr_reader :queries
+
+      Query = Struct.new(:cypher, :parameters, :pretty_cypher, :context)
+
+      def initialize
+        @queries = []
+      end
+
+      def append(*args)
+        query = case args.map(&:class)
+                when [String], [String, Hash]
+                  Query.new(args[0], args[1] || {})
+                when [::Neo4j::Core::Query]
+                  args[0]
+                else
+                  fail ArgumentError, "Could not determine query from arguments: #{args.inspect}"
+                end
+
+        @queries << query
+      end
+
+      def query
+        # `nil` sessions are just a workaround until
+        # we phase out `Query` objects containing sessions
+        Neo4j::Core::Query.new(session: nil)
+      end
+    end
+  end
+end

data/lib/neo4j/core/query_clauses.rb

@@ -0,0 +1,727 @@
+module Neo4j
+  module Core
+    module QueryClauses
+      class ArgError < StandardError
+        attr_reader :arg_part
+        def initialize(arg_part = nil)
+          super
+          @arg_part = arg_part
+        end
+      end
+
+      class Clause
+        UNDERSCORE = '_'
+        COMMA_SPACE = ', '
+        AND = ' AND '
+        PRETTY_NEW_LINE = "\n  "
+
+        attr_accessor :params, :arg
+        attr_reader :options, :param_vars_added
+
+        def initialize(arg, params, options = {})
+          @arg = arg
+          @options = options
+          @params = params
+          @param_vars_added = []
+        end
+
+        def value
+          return @value if @value
+
+          [String, Symbol, Integer, Hash, NilClass].each do |arg_class|
+            from_method = "from_#{arg_class.name.downcase}"
+            return @value = send(from_method, @arg) if @arg.is_a?(arg_class) && respond_to?(from_method)
+          end
+
+          fail ArgError
+        rescue ArgError => arg_error
+          message = "Invalid argument for #{self.class.keyword}.  Full arguments: #{@arg.inspect}"
+          message += " | Invalid part: #{arg_error.arg_part.inspect}" if arg_error.arg_part
+
+          raise ArgumentError, message
+        end
+
+        def from_hash(value)
+          fail ArgError if !respond_to?(:from_key_and_value)
+
+          value.map do |k, v|
+            from_key_and_value k, v
+          end
+        end
+
+        def from_string(value)
+          value
+        end
+
+        def node_from_key_and_value(key, value, options = {})
+          prefer = options[:prefer] || :var
+          var = var_from_key_and_value(key, value, prefer)
+          label = label_from_key_and_value(key, value, prefer)
+
+          attributes = attributes_from_key_and_value(key, value)
+
+          prefix_value = value
+          if value.is_a?(Hash)
+            prefix_value = (value.keys.join(UNDERSCORE) if value.values.any? { |v| v.is_a?(Hash) })
+          end
+
+          prefix_array = [key, prefix_value].tap(&:compact!).join(UNDERSCORE)
+          formatted_attributes = attributes_string(attributes, "#{prefix_array}#{UNDERSCORE}")
+          "(#{var}#{format_label(label)}#{formatted_attributes})"
+        end
+
+        def var_from_key_and_value(key, value, prefer = :var)
+          case value
+          when String, Symbol, Class, Module, NilClass, Array then key
+          when Hash
+            key if _use_key_for_var?(value, prefer)
+          else
+            fail ArgError, value
+          end
+        end
+
+        def label_from_key_and_value(key, value, prefer = :var)
+          case value
+          when String, Symbol, Array, NilClass then value
+          when Class, Module then value.name
+          when Hash
+            if value.values.map(&:class) == [Hash]
+              value.first.first
+            elsif !_use_key_for_var?(value, prefer)
+              key
+            end
+          else
+            fail ArgError, value
+          end
+        end
+
+        def _use_key_for_var?(value, prefer)
+          _nested_value_hash?(value) || prefer == :var
+        end
+
+        def _nested_value_hash?(value)
+          value.values.any? { |v| v.is_a?(Hash) }
+        end
+
+        def attributes_from_key_and_value(_key, value)
+          return nil unless value.is_a?(Hash)
+
+          value.values.map(&:class) == [Hash] ? value.first[1] : value
+        end
+
+        class << self
+          def keyword
+            self::KEYWORD
+          end
+
+          def keyword_downcase
+            keyword.downcase
+          end
+
+          def from_args(args, params, options = {})
+            args.flatten!
+            args.map { |arg| from_arg(arg, params, options) }.tap(&:compact!)
+          end
+
+          def from_arg(arg, params, options = {})
+            new(arg, params, options) if !arg.respond_to?(:empty?) || !arg.empty?
+          end
+
+          def to_cypher(clauses, pretty = false)
+            string = clause_string(clauses, pretty)
+
+            final_keyword = if pretty
+                              "#{clause_color}#{keyword}#{ANSI::CLEAR}"
+                            else
+                              keyword
+                            end
+
+            "#{final_keyword} #{string}" if !string.empty?
+          end
+
+          def clause_string(clauses, pretty)
+            join_string = pretty ? clause_join + PRETTY_NEW_LINE : clause_join
+
+            strings = clause_strings(clauses)
+            stripped_string = strings.join(join_string).strip
+            pretty && strings.size > 1 ? PRETTY_NEW_LINE + stripped_string : stripped_string
+          end
+
+          def clause_join
+            ''
+          end
+
+          def clause_color
+            ANSI::CYAN
+          end
+
+          def from_key_and_single_value(key, value)
+            value.to_sym == :neo_id ? "ID(#{key})" : "#{key}.#{value}"
+          end
+        end
+
+        def self.paramaterize_key!(key)
+          key.tr_s!('^a-zA-Z0-9', UNDERSCORE)
+          key.gsub!(/^_+|_+$/, '')
+        end
+
+        def add_param(key, value)
+          @param_vars_added << key
+          @params.add_param(key, value)
+        end
+
+        def add_params(keys_and_values)
+          @param_vars_added += keys_and_values.keys
+          @params.add_params(keys_and_values)
+        end
+
+        private
+
+        def key_value_string(key, value, previous_keys = [], is_set = false)
+          param = (previous_keys << key).join(UNDERSCORE)
+          self.class.paramaterize_key!(param)
+
+          if value.is_a?(Range)
+            range_key_value_string(key, value, previous_keys, param)
+          else
+            value = value.first if array_value?(value, is_set) && value.size == 1
+
+            param = add_param(param, value)
+
+            "#{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}}"
+        end
+
+        def array_value?(value, is_set)
+          value.is_a?(Array) && !is_set
+        end
+
+        def format_label(label_arg)
+          return label_arg.map { |arg| format_label(arg) }.join if label_arg.is_a?(Array)
+
+          label_arg = label_arg.to_s.strip
+          if !label_arg.empty? && label_arg[0] != ':'
+            label_arg = "`#{label_arg}`" unless label_arg[' ']
+            label_arg = ":#{label_arg}"
+          end
+          label_arg
+        end
+
+        def attributes_string(attributes, prefix = '')
+          return '' if not attributes
+
+          attributes_string = attributes.map do |key, value|
+            if value.to_s =~ /^{.+}$/
+              "#{key}: #{value}"
+            else
+              param_key = "#{prefix}#{key}".gsub(/:+/, '_')
+              param_key = add_param(param_key, value)
+              "#{key}: {#{param_key}}"
+            end
+          end.join(Clause::COMMA_SPACE)
+
+          " {#{attributes_string}}"
+        end
+      end
+
+      class StartClause < Clause
+        KEYWORD = 'START'
+
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
+
+        def from_key_and_value(key, value)
+          case value
+          when String, Symbol
+            "#{key} = #{value}"
+          else
+            fail ArgError, value
+          end
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+        end
+      end
+
+      class WhereClause < Clause
+        KEYWORD = 'WHERE'
+
+        PAREN_SURROUND_REGEX = /^\s*\(.+\)\s*$/
+
+        def from_key_and_value(key, value, previous_keys = [])
+          case value
+          when Hash then hash_key_value_string(key, value, previous_keys)
+          when NilClass then "#{key} IS NULL"
+          when Regexp then regexp_key_value_string(key, value, previous_keys)
+          else
+            key_value_string(key, value, previous_keys)
+          end
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.flat_map do |clause|
+              Array(clause.value).map do |v|
+                (clause.options[:not] ? 'NOT' : '') + (v.to_s.match(PAREN_SURROUND_REGEX) ? v.to_s : "(#{v})")
+              end
+            end
+          end
+
+          def clause_join
+            Clause::AND
+          end
+        end
+
+        private
+
+        def hash_key_value_string(key, value, previous_keys)
+          value.map do |k, v|
+            if k.to_sym == :neo_id
+              v = Array(v).map { |item| (item.respond_to?(:neo_id) ? item.neo_id : item).to_i }
+              key_value_string("ID(#{key})", v)
+            else
+              "#{key}.#{from_key_and_value(k, v, previous_keys + [key])}"
+            end
+          end.join(AND)
+        end
+
+        def regexp_key_value_string(key, value, previous_keys)
+          pattern = (value.casefold? ? '(?i)' : '') + value.source
+
+          param = [previous_keys + [key]].join(UNDERSCORE)
+          self.class.paramaterize_key!(param)
+
+          param = add_param(param, pattern)
+
+          "#{key} =~ {#{param}}"
+        end
+
+        class << self
+          ARG_HAS_QUESTION_MARK_REGEX = /(^|\(|\s)\?(\s|\)|$)/
+
+          def from_args(args, params, options = {})
+            query_string, params_arg = args
+
+            if query_string.is_a?(String) && (query_string.match(ARG_HAS_QUESTION_MARK_REGEX) || params_arg.is_a?(Hash))
+              if params_arg.is_a?(Hash)
+                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")
+              end
+
+              [from_arg(query_string, params, options)]
+            else
+              super
+            end
+          end
+        end
+      end
+
+      class CallClause < Clause
+        KEYWORD = 'CALL'
+
+        def from_string(value)
+          value
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            " #{KEYWORD} "
+          end
+        end
+      end
+
+      class MatchClause < Clause
+        KEYWORD = 'MATCH'
+
+        def from_symbol(value)
+          '(' + from_string(value.to_s) + ')'
+        end
+
+        def from_key_and_value(key, value)
+          node_from_key_and_value(key, value)
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+        end
+      end
+
+      class OptionalMatchClause < MatchClause
+        KEYWORD = 'OPTIONAL MATCH'
+      end
+
+      class WithClause < Clause
+        KEYWORD = 'WITH'
+
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
+
+        def from_key_and_value(key, value)
+          "#{value} AS #{key}"
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+        end
+      end
+
+      class WithDistinctClause < WithClause
+        KEYWORD = 'WITH DISTINCT'
+      end
+
+      class UsingClause < Clause
+        KEYWORD = 'USING'
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            " #{keyword} "
+          end
+        end
+      end
+
+      class CreateClause < Clause
+        KEYWORD = 'CREATE'
+
+        def from_string(value)
+          value
+        end
+
+        def from_symbol(value)
+          "(:#{value})"
+        end
+
+        def from_hash(hash)
+          if hash.values.any? { |value| value.is_a?(Hash) }
+            hash.map do |key, value|
+              from_key_and_value(key, value)
+            end
+          else
+            "(#{attributes_string(hash)})"
+          end
+        end
+
+        def from_key_and_value(key, value)
+          node_from_key_and_value(key, value, prefer: :label)
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            ', '
+          end
+
+          def clause_color
+            ANSI::GREEN
+          end
+        end
+      end
+
+      class CreateUniqueClause < CreateClause
+        KEYWORD = 'CREATE UNIQUE'
+      end
+
+      class MergeClause < CreateClause
+        KEYWORD = 'MERGE'
+
+        class << self
+          def clause_color
+            ANSI::MAGENTA
+          end
+
+          def clause_join
+            ' MERGE '
+          end
+        end
+      end
+
+      class DeleteClause < Clause
+        KEYWORD = 'DELETE'
+
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+
+          def clause_color
+            ANSI::RED
+          end
+        end
+      end
+
+      class DetachDeleteClause < DeleteClause
+        KEYWORD = 'DETACH DELETE'
+      end
+
+      class OrderClause < Clause
+        KEYWORD = 'ORDER BY'
+
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
+
+        def from_key_and_value(key, value)
+          case value
+          when String, Symbol
+            self.class.from_key_and_single_value(key, value)
+          when Array
+            value.map do |v|
+              v.is_a?(Hash) ? from_key_and_value(key, v) : self.class.from_key_and_single_value(key, v)
+            end
+          when Hash
+            value.map { |k, v| "#{self.class.from_key_and_single_value(key, k)} #{v.upcase}" }
+          end
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+        end
+      end
+
+      class LimitClause < Clause
+        KEYWORD = 'LIMIT'
+
+        def from_string(value)
+          param_var = "#{self.class.keyword_downcase}_#{value}"
+          param_var = add_param(param_var, value.to_i)
+          "{#{param_var}}"
+        end
+
+        def from_integer(value)
+          from_string(value)
+        end
+
+        def from_nilclass(_value)
+          ''
+        end
+
+        class << self
+          def clause_strings(clauses)
+            result_clause = clauses.last
+
+            clauses[0..-2].map(&:param_vars_added).flatten.grep(/^limit_\d+$/).each do |var|
+              result_clause.params.remove_param(var)
+            end
+
+            [result_clause.value]
+          end
+        end
+      end
+
+      class SkipClause < Clause
+        KEYWORD = 'SKIP'
+
+        def from_string(value)
+          clause_id = "#{self.class.keyword_downcase}_#{value}"
+          clause_id = add_param(clause_id, value.to_i)
+          "{#{clause_id}}"
+        end
+
+        def from_integer(value)
+          clause_id = "#{self.class.keyword_downcase}_#{value}"
+          clause_id = add_param(clause_id, value)
+          "{#{clause_id}}"
+        end
+
+        class << self
+          def clause_strings(clauses)
+            result_clause = clauses.last
+
+            clauses[0..-2].map(&:param_vars_added).flatten.grep(/^skip_\d+$/).each do |var|
+              result_clause.params.remove_param(var)
+            end
+
+            [result_clause.value]
+          end
+        end
+      end
+
+      class SetClause < Clause
+        KEYWORD = 'SET'
+
+        def from_key_and_value(key, value)
+          case value
+          when String, Symbol then "#{key}:`#{value}`"
+          when Hash
+            if @options[:set_props]
+              param = add_param("#{key}_set_props", value)
+              "#{key} = {#{param}}"
+            else
+              value.map { |k, v| key_value_string("#{key}.`#{k}`", v, ['setter'], true) }
+            end
+          when Array then value.map { |v| from_key_and_value(key, v) }
+          when NilClass then []
+          else
+            fail ArgError, value
+          end
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+
+          def clause_color
+            ANSI::YELLOW
+          end
+        end
+      end
+
+      class OnCreateSetClause < SetClause
+        KEYWORD = 'ON CREATE SET'
+
+        def initialize(*args)
+          super
+          @options[:set_props] = false
+        end
+      end
+
+      class OnMatchSetClause < OnCreateSetClause
+        KEYWORD = 'ON MATCH SET'
+      end
+
+      class RemoveClause < Clause
+        KEYWORD = 'REMOVE'
+
+        def from_key_and_value(key, value)
+          case value
+          when /^:/
+            "#{key}:`#{value[1..-1]}`"
+          when String
+            "#{key}.#{value}"
+          when Symbol
+            "#{key}:`#{value}`"
+          when Array
+            value.map do |v|
+              from_key_and_value(key, v)
+            end
+          else
+            fail ArgError, value
+          end
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+        end
+      end
+
+      class UnwindClause < Clause
+        KEYWORD = 'UNWIND'
+
+        def from_key_and_value(key, value)
+          case value
+          when String, Symbol
+            "#{value} AS #{key}"
+          when Array
+            "#{value.inspect} AS #{key}"
+          else
+            fail ArgError, value
+          end
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            ' UNWIND '
+          end
+        end
+      end
+
+      class ReturnClause < Clause
+        KEYWORD = 'RETURN'
+
+        def from_symbol(value)
+          from_string(value.to_s)
+        end
+
+        def from_key_and_value(key, value)
+          case value
+          when Array
+            value.map do |v|
+              from_key_and_value(key, v)
+            end.join(Clause::COMMA_SPACE)
+          when String, Symbol
+            self.class.from_key_and_single_value(key, value)
+          else
+            fail ArgError, value
+          end
+        end
+
+        class << self
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+        end
+      end
+    end
+  end
+end