neo4j-core 0.0.1-java

data/lib/neo4j-core/cypher/cypher.rb

@@ -0,0 +1,867 @@
+module Neo4j
+  module Core
+    module Cypher
+
+      module MathFunctions
+        def abs(value=nil)
+          _add_math_func(:abs, value)
+        end
+
+        def sqrt(value=nil)
+          _add_math_func(:sqrt, value)
+        end
+
+        def round(value=nil)
+          _add_math_func(:round, value)
+        end
+
+        def sign(value=nil)
+          _add_math_func(:sign, value)
+        end
+
+        def _add_math_func(name, value=nil)
+          value ||= self.respond_to?(:var_name) ? self.var_name : to_s
+          expressions.delete(self)
+          Property.new(expressions, nil, name).to_function!(value)
+        end
+      end
+
+      module MathOperator
+        def -(other)
+          ExprOp.new(self, other, '-')
+        end
+
+        def +(other)
+          ExprOp.new(self, other, '+')
+        end
+      end
+
+      module Comparable
+        def <(other)
+          ExprOp.new(self, other, '<')
+        end
+
+        def <=(other)
+          ExprOp.new(self, other, '<=')
+        end
+
+        def =~(other)
+          ExprOp.new(self, other, '=~')
+        end
+
+        def >(other)
+          ExprOp.new(self, other, '>')
+        end
+
+        def >=(other)
+          ExprOp.new(self, other, '>=')
+        end
+
+        ## Only in 1.9
+        if RUBY_VERSION > "1.9.0"
+          eval %{
+            def !=(other)
+              other.is_a?(String) ?  ExprOp.new(self, other, "!=") : super
+            end  }
+        end
+
+        def ==(other)
+          if other.is_a?(Fixnum) || other.is_a?(String) || other.is_a?(Regexp)
+            ExprOp.new(self, other, "=")
+          else
+            super
+          end
+        end
+      end
+
+      module PredicateMethods
+        def all?(&block)
+          self.respond_to?(:iterable)
+          Predicate.new(expressions, :op => 'all', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block)
+        end
+
+        def extract(&block)
+          Predicate.new(expressions, :op => 'extract', :clause => :return, :input => input, :iterable => iterable, :predicate_block => block)
+        end
+
+        def filter(&block)
+          Predicate.new(expressions, :op => 'filter', :clause => :return, :input => input, :iterable => iterable, :predicate_block => block)
+        end
+
+        def any?(&block)
+          Predicate.new(@expressions, :op => 'any', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block)
+        end
+
+        def none?(&block)
+          Predicate.new(@expressions, :op => 'none', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block)
+        end
+
+        def single?(&block)
+          Predicate.new(@expressions, :op => 'single', :clause => :where, :input => input, :iterable => iterable, :predicate_block => block)
+        end
+
+      end
+
+      module Variable
+        attr_accessor :return_method
+
+        def distinct
+          self.return_method = {:name => 'distinct', :bracket => false}
+          self
+        end
+
+        def [](prop_name)
+          Property.new(expressions, self, prop_name)
+        end
+
+        def as(v)
+          @var_name = v
+          self
+        end
+
+        def neo_id
+          Property.new(@expressions, self, 'ID').to_function!
+        end
+
+        def property?(p)
+          p = Property.new(expressions, self, p)
+          p.binary_operator("has")
+        end
+
+        def exist?
+          p = Property.new(expressions, self, p)
+          p.binary_operator("", " is null")
+        end
+      end
+
+      module Matchable
+        # This operator means related to, without regard to type or direction.
+        # @param [Symbol, #var_name] other either a node (Symbol, #var_name)
+        # @return [MatchRelLeft, MatchNode]
+        def <=>(other)
+          MatchNode.new(self, other, expressions, :both)
+        end
+
+        # This operator means outgoing related to
+        # @param [Symbol, #var_name, String] other the relationship
+        # @return [MatchRelLeft, MatchNode]
+        def >(other)
+          MatchRelLeft.new(self, other, expressions, :outgoing)
+        end
+
+        # This operator means any direction related to
+        # @param (see #>)
+        # @return [MatchRelLeft, MatchNode]
+        def -(other)
+          MatchRelLeft.new(self, other, expressions, :both)
+        end
+
+        # This operator means incoming related to
+        # @param (see #>)
+        # @return [MatchRelLeft, MatchNode]
+        def <(other)
+          MatchRelLeft.new(self, other, expressions, :incoming)
+        end
+
+        # Outgoing relationship to other node
+        # @param [Symbol, #var_name] other either a node (Symbol, #var_name)
+        # @return [MatchRelLeft, MatchNode]
+        def >>(other)
+          MatchNode.new(self, other, expressions, :outgoing)
+        end
+
+        # Incoming relationship to other node
+        # @param [Symbol, #var_name] other either a node (Symbol, #var_name)
+        # @return [MatchRelLeft, MatchNode]
+        def <<(other)
+          MatchNode.new(self, other, expressions, :incoming)
+        end
+      end
+
+      class Expression
+        attr_reader :expressions
+        attr_accessor :separator, :clause
+
+        def initialize(expressions, clause)
+          @clause = clause
+          @expressions = expressions
+          insert_last(clause)
+          @separator = ","
+        end
+
+        def insert_last(clause)
+          i = @expressions.reverse.index { |e| e.clause == clause }
+          if i.nil?
+            @expressions << self
+          else
+            pos = @expressions.size - i
+            @expressions.insert(pos, self)
+          end
+        end
+
+        def prefixes
+          {:start => "START", :where => " WHERE", :match => " MATCH", :return => " RETURN", :order_by => " ORDER BY", :skip => " SKIP", :limit => " LIMIT"}
+        end
+
+        def prefix
+          prefixes[clause]
+        end
+
+        def valid?
+          true
+        end
+
+      end
+
+      class Property
+        attr_reader :expressions, :var_name
+        include Comparable
+        include MathOperator
+        include MathFunctions
+        include PredicateMethods
+
+        def initialize(expressions, var, prop_name)
+          @var = var.respond_to?(:var_name) ? var.var_name : var
+          @expressions = expressions
+          @prop_name = prop_name
+          @var_name = @prop_name ? "#{@var.to_s}.#{@prop_name}" : @var.to_s
+        end
+
+        def to_function!(var = @var.to_s)
+          @var_name = "#{@prop_name}(#{var})"
+          self
+        end
+
+        def as(new_name)
+          @var_name = "#{@var_name} AS #{new_name}"
+        end
+
+        # required by the Predicate Methods Module
+        # @see PredicateMethods
+        def iterable
+          var_name
+        end
+
+        def input
+          self
+        end
+
+        def in?(values)
+          binary_operator("", " IN [#{values.map { |x| %Q["#{x}"] }.join(',')}]")
+        end
+
+        def distinct
+          @var_name = "distinct #{@var_name}"
+          self
+        end
+
+        def length
+          @prop_name = "length"
+          to_function!
+          self
+        end
+
+        %w[count sum avg min max collect head last tail].each do |meth_name|
+          define_method(meth_name) do
+            function(meth_name.to_s)
+          end
+        end
+
+        def function(func_name_pre, func_name_post = "")
+          ExprOp.new(self, nil, func_name_pre, func_name_post)
+        end
+
+        def binary_operator(op, post_fix = "")
+          ExprOp.new(self, nil, op, post_fix).binary!
+        end
+      end
+
+      class Start < Expression
+        attr_reader :var_name
+        include Variable
+        include Matchable
+
+        def initialize(var_name, expressions)
+          @var_name = "#{var_name}#{expressions.size}"
+          super(expressions, :start)
+        end
+
+      end
+
+      class StartNode < Start
+        attr_reader :nodes
+
+        def initialize(nodes, expressions)
+          super("n", expressions)
+          @nodes = nodes.map { |n| n.respond_to?(:neo_id) ? n.neo_id : n }
+        end
+
+        def to_s
+          "#{var_name}=node(#{nodes.join(',')})"
+        end
+      end
+
+      class StartRel < Start
+        attr_reader :rels
+
+        def initialize(rels, expressions)
+          super("r", expressions)
+          @rels = rels.map { |n| n.respond_to?(:neo_id) ? n.neo_id : n }
+        end
+
+        def to_s
+          "#{var_name}=relationship(#{rels.join(',')})"
+        end
+      end
+
+      class NodeQuery < Start
+        attr_reader :index_name, :query
+
+        def initialize(index_class, query, index_type, expressions)
+          super("n", expressions)
+          @index_name = index_class.index_name_for_type(index_type)
+          @query = query
+        end
+
+        def to_s
+          "#{var_name}=node:#{index_name}(#{query})"
+        end
+      end
+
+      class NodeLookup < Start
+        attr_reader :index_name, :query
+
+        def initialize(index_class, key, value, expressions)
+          super("n", expressions)
+          index_type = index_class.index_type(key.to_s)
+          raise "No index on #{index_class} property #{key}" unless index_type
+          @index_name = index_class.index_name_for_type(index_type)
+          @query = %Q[#{key}="#{value}"]
+        end
+
+        def to_s
+          %Q[#{var_name}=node:#{index_name}(#{query})]
+        end
+
+      end
+
+      # The return statement in the cypher query
+      class Return < Expression
+        attr_reader :var_name
+
+        def initialize(name_or_ref, expressions, opts = {})
+          super(expressions, :return)
+          @name_or_ref = name_or_ref
+          @name_or_ref.referenced! if @name_or_ref.respond_to?(:referenced!)
+          @var_name = @name_or_ref.respond_to?(:var_name) ? @name_or_ref.var_name : @name_or_ref.to_s
+          opts.each_pair { |k, v| self.send(k, v) }
+        end
+
+        def return_method
+          @name_or_ref.respond_to?(:return_method) && @name_or_ref.return_method
+        end
+
+        def as_return_method
+          if return_method[:bracket]
+            "#{return_method[:name]}(#@var_name)"
+          else
+            "#{return_method[:name]} #@var_name"
+          end
+        end
+
+        # Specifies an <tt>ORDER BY</tt> cypher query
+        # @param [Property] props the properties which should be sorted
+        # @return self
+        def asc(*props)
+          @order_by ||= OrderBy.new(expressions)
+          @order_by.asc(props)
+          self
+        end
+
+        # Specifies an <tt>ORDER BY</tt> cypher query
+        # @param [Property] props the properties which should be sorted
+        # @return self
+        def desc(*props)
+          @order_by ||= OrderBy.new(expressions)
+          @order_by.desc(props)
+          self
+        end
+
+        # Creates a <tt>SKIP</tt> cypher clause
+        # @param [Fixnum] val the number of entries to skip
+        # @return self
+        def skip(val)
+          Skip.new(expressions, val)
+          self
+        end
+
+        # Creates a <tt>LIMIT</tt> cypher clause
+        # @param [Fixnum] val the number of entries to limit
+        # @return self
+        def limit(val)
+          Limit.new(expressions, val)
+          self
+        end
+
+        def to_s
+          return_method ? as_return_method : var_name.to_s
+        end
+      end
+
+      class Skip < Expression
+        def initialize(expressions, value)
+          super(expressions, :skip)
+          @value = value
+        end
+
+        def to_s
+          @value
+        end
+      end
+
+      class Limit < Expression
+        def initialize(expressions, value)
+          super(expressions, :limit)
+          @value = value
+        end
+
+        def to_s
+          @value
+        end
+      end
+
+      class OrderBy < Expression
+        def initialize(expressions)
+          super(expressions, :order_by)
+        end
+
+        def asc(props)
+          @asc ||= []
+          @asc += props
+        end
+
+        def desc(props)
+          @desc ||= []
+          @desc += props
+        end
+
+        def to_s
+          s = []
+          s << @asc.map { |p| p.var_name }.join(",") if @asc
+          s << @desc.map { |p| p.var_name.to_s + " DESC" }.join(",") if @desc
+          s.join(',')
+        end
+      end
+
+      class Match < Expression
+        attr_reader :dir, :expressions, :left, :right, :var_name, :dir_op
+        attr_accessor :algorithm, :next, :prev
+        include Variable
+
+        def initialize(left, right, expressions, dir, dir_op)
+          super(expressions, :match)
+          @var_name = "m#{expressions.size}"
+          @dir = dir
+          @dir_op = dir_op
+          @prev = left if left.is_a?(Match)
+          @left = left
+          @right = right
+        end
+
+
+        def nodes
+          Entities.new(@expressions, "nodes", self)
+        end
+
+        def rels
+          Entities.new(@expressions, "relationships", self)
+        end
+
+        def length
+          self.return_method = {:name => 'length', :bracket => true}
+          self
+        end
+
+        def find_match_start
+          c = self
+          while (c.prev) do
+            c = c.prev
+          end
+          c
+        end
+
+        def left_var_name
+          @left.respond_to?(:var_name) ? @left.var_name : @left.to_s
+        end
+
+        def right_var_name
+          @right.respond_to?(:var_name) ? @right.var_name : @right.to_s
+        end
+
+        def right_expr
+          @right.respond_to?(:expr) ? @right.expr : right_var_name
+        end
+
+        def referenced!
+          @referenced = true
+        end
+
+        def referenced?
+          !!@referenced
+        end
+
+        def to_s
+          curr = find_match_start
+          result = (referenced? || curr.referenced?) ? "#{var_name} = " : ""
+          result << (algorithm ? "#{algorithm}(" : "")
+          begin
+            result << curr.expr
+          end while (curr = curr.next)
+          result << ")" if algorithm
+          result
+        end
+      end
+
+      class MatchRelLeft < Match
+        def initialize(left, right, expressions, dir)
+          super(left, right, expressions, dir, dir == :incoming ? '<-' : '-')
+        end
+
+        # @param [Symbol,NodeVar,String] other part of the match cypher statement.
+        # @return [MatchRelRight] the right part of an relationship cypher query.
+        def >(other)
+          expressions.delete(self)
+          self.next = MatchRelRight.new(self, other, expressions, :outgoing)
+        end
+
+        # @see #>
+        # @return (see #>)
+        def <(other)
+          expressions.delete(self)
+          self.next = MatchRelRight.new(self, other, expressions, :incoming)
+        end
+
+        # @see #>
+        # @return (see #>)
+        def -(other)
+          expressions.delete(self)
+          self.next = MatchRelRight.new(self, other, expressions, :both)
+        end
+
+        # @return [String] a cypher string for this match.
+        def expr
+          if prev
+            # we have chained more then one relationships in a match expression
+            "#{dir_op}[#{right_expr}]"
+          else
+            # the right is an relationship and could be an expressions, e.g "r?"
+            "(#{left_var_name})#{dir_op}[#{right_expr}]"
+          end
+        end
+      end
+
+      class MatchRelRight < Match
+        # @param left the left part of the query
+        # @param [Symbol,NodeVar,String] right part of the match cypher statement.
+        def initialize(left, right, expressions, dir)
+          super(left, right, expressions, dir, dir == :outgoing ? '->' : '-')
+        end
+
+        # @param [Symbol,NodeVar,String] other part of the match cypher statement.
+        # @return [MatchRelLeft] the right part of an relationship cypher query.
+        def >(other)
+          expressions.delete(self)
+          self.next = MatchRelLeft.new(self, other, expressions, :outgoing)
+        end
+
+        # @see #>
+        # @return (see #>)
+        def <(other)
+          expressions.delete(self)
+          self.next = MatchRelLeft.new(self, other, expressions, :incoming)
+        end
+
+        # @see #>
+        # @return (see #>)
+        def -(other)
+          expressions.delete(self)
+          self.next = MatchRelLeft.new(self, other, expressions, :both)
+        end
+
+        # @return [String] a cypher string for this match.
+        def expr
+          "#{dir_op}(#{right_var_name})"
+        end
+      end
+
+      class MatchNode < Match
+        attr_reader :dir_op
+
+        def initialize(left, right, expressions, dir)
+          dir_op = case dir
+                     when :outgoing then
+                       "-->"
+                     when :incoming then
+                       "<--"
+                     when :both then
+                       "--"
+                   end
+          super(left, right, expressions, dir, dir_op)
+        end
+
+        # @return [String] a cypher string for this match.
+        def expr
+          if prev
+            # we have chained more then one relationships in a match expression
+            "#{dir_op}(#{right_expr})"
+          else
+            # the right is an relationship and could be an expressions, e.g "r?"
+            "(#{left_var_name})#{dir_op}(#{right_expr})"
+          end
+        end
+
+        def <<(other)
+          expressions.delete(self)
+          self.next = MatchNode.new(self, other, expressions, :incoming)
+        end
+
+        def >>(other)
+          expressions.delete(self)
+          self.next = MatchNode.new(self, other, expressions, :outgoing)
+        end
+
+        # @param [Symbol,NodeVar,String] other part of the match cypher statement.
+        # @return [MatchRelRight] the right part of an relationship cypher query.
+        def >(other)
+          expressions.delete(self)
+          self.next = MatchRelLeft.new(self, other, expressions, :outgoing)
+        end
+
+        # @see #>
+        # @return (see #>)
+        def <(other)
+          expressions.delete(self)
+          self.next = MatchRelLeft.new(self, other, expressions, :incoming)
+        end
+
+        # @see #>
+        # @return (see #>)
+        def -(other)
+          expressions.delete(self)
+          self.next = MatchRelLeft.new(self, other, expressions, :both)
+        end
+
+      end
+
+      # Represents an unbound node variable used in match statements
+      class NodeVar
+        include Variable
+        include Matchable
+
+        # @return the name of the variable
+        attr_reader :var_name
+        attr_reader :expressions
+
+        def initialize(expressions, variables)
+          @var_name = "v#{variables.size}"
+          variables << self
+          @expressions = expressions
+        end
+
+        # @return [String] a cypher string for this node variable
+        def to_s
+          var_name
+        end
+
+      end
+
+      # represent an unbound relationship variable used in match,where,return statement
+      class RelVar
+        include Variable
+
+        attr_reader :var_name, :expr, :expressions
+
+        def initialize(expressions, variables, expr)
+          variables << self
+          @expr = expr
+          @expressions = expressions
+          guess = expr ? /([[:alpha:]]*)/.match(expr)[1] : ""
+          @var_name = guess.empty? ? "v#{variables.size}" : guess
+        end
+
+        def rel_type
+          Property.new(@expressions, self, 'type').to_function!
+        end
+
+        # @return [String] a cypher string for this relationship variable
+        def to_s
+          var_name
+        end
+
+      end
+
+      class ExprOp < Expression
+        attr_reader :left, :right, :op, :neg, :post_fix
+        include MathFunctions
+
+        def initialize(left, right, op, post_fix = "")
+          super(left.expressions, :where)
+          @op = op
+          @post_fix = post_fix
+          self.expressions.delete(left)
+          self.expressions.delete(right)
+          @left = quote(left)
+          if regexp?(right)
+            @op = "=~"
+            @right = to_regexp(right)
+          else
+            @right = right && quote(right)
+          end
+          @neg = nil
+        end
+
+        def separator
+          " "
+        end
+
+        def quote(val)
+          if val.respond_to?(:var_name)
+            val.var_name
+          else
+            val.is_a?(String) ? %Q["#{val}"] : val
+          end
+        end
+
+        def regexp?(right)
+          @op == "=~" || right.is_a?(Regexp)
+        end
+
+        def to_regexp(val)
+          %Q[/#{val.respond_to?(:source) ? val.source : val.to_s}/]
+        end
+
+        def count
+          ExprOp.new(self, nil, 'count')
+        end
+
+        def &(other)
+          ExprOp.new(self, other, "and")
+        end
+
+        def |(other)
+          ExprOp.new(self, other, "or")
+        end
+
+        def -@
+          @neg = "not"
+          self
+        end
+
+        def not
+          @neg = "not"
+          self
+        end
+
+        # Only in 1.9
+        if RUBY_VERSION > "1.9.0"
+          eval %{
+             def !
+               @neg = "not"
+               self
+             end
+             }
+        end
+
+        def left_to_s
+          left.is_a?(ExprOp) ? "(#{left})" : left
+        end
+
+        def right_to_s
+          right.is_a?(ExprOp) ? "(#{right})" : right
+        end
+
+        def binary!
+          @binary = true
+          self
+        end
+
+        def valid?
+          #        puts "valid? @binary=#{@binary} (#@left #@op #@right) in clause #{clause} ret #{@binary ? !!@left : !!@left && !!@right}"
+          # it is only valid in a where clause if it's either binary or it has right and left values
+          @binary ? @left : @left && @right
+        end
+
+        def to_s
+          if @right
+            neg ? "#{neg}(#{left_to_s} #{op} #{right_to_s})" : "#{left_to_s} #{op} #{right_to_s}"
+          else
+            # binary operator
+            neg ? "#{neg}#{op}(#{left_to_s}#{post_fix})" : "#{op}(#{left_to_s}#{post_fix})"
+          end
+        end
+      end
+
+      class Where < Expression
+        def initialize(expressions, where_statement = nil)
+          super(expressions, :where)
+          @where_statement = where_statement
+        end
+
+        def to_s
+          @where_statement.to_s
+        end
+      end
+
+      class Predicate < Expression
+        attr_accessor :params
+
+        def initialize(expressions, params)
+          @params = params
+          @identifier = :x
+          params[:input].referenced! if params[:input].respond_to?(:referenced!)
+          super(expressions, params[:clause])
+        end
+
+        def identifier(i)
+          @identifier = i
+          self
+        end
+
+        def to_s
+          input = params[:input]
+          if input.kind_of?(Property)
+            yield_param = Property.new([], @identifier, nil)
+            args = ""
+          else
+            yield_param = NodeVar.new([], []).as(@identifier.to_sym)
+            args = "(#{input.var_name})"
+          end
+          context = Neo4j::Cypher.new(yield_param, &params[:predicate_block])
+          context.expressions.each { |e| e.clause = nil }
+          if params[:clause] == :return
+            where_or_colon = ':'
+          else
+            where_or_colon = 'WHERE'
+          end
+          predicate_value = context.to_s[1..-1] # skip separator ,
+          "#{params[:op]}(#@identifier in #{params[:iterable]}#{args} #{where_or_colon} #{predicate_value})"
+        end
+      end
+
+      class Entities
+        include PredicateMethods
+        attr_reader :input, :expressions, :iterable
+
+        def initialize(expressions, iterable, input)
+          @iterable = iterable
+          @input = input
+          @expressions = expressions
+        end
+
+      end
+
+    end
+
+  end
+
+end