neo4j-core 2.0.0.alpha.1-java → 2.0.0-java

data/lib/neo4j-core.rb

@@ -1,4 +1,12 @@
 require 'java'
+include Java
+
+module Neo4j
+  # Enumerator has been moved to top level in Ruby 1.9.2, make it compatible with Ruby 1.8.7
+  Enumerator = Enumerable::Enumerator unless defined? Enumerator
+end
+
+require 'neo4j-core/version'
 require 'neo4j/config'
 
 require 'neo4j-community'
@@ -12,6 +20,7 @@ require 'neo4j-core/database'
 require 'neo4j-core/to_java'
 
 require 'neo4j-core/property/property'
+require 'neo4j-core/property/java'
 
 require 'neo4j-core/rels/rels'
 require 'neo4j-core/rels/traverser'
@@ -29,9 +38,13 @@ require 'neo4j-core/index/indexer_registry'
 require 'neo4j-core/index/index_config'
 require 'neo4j-core/index/indexer'
 require 'neo4j-core/index/lucene_query'
+require 'neo4j-core/index/unique_factory'
 
 require 'neo4j-core/equal/equal'
 
+require 'neo4j-core/wrapper/class_methods'
+require 'neo4j-core/wrapper/wrapper'
+
 require 'neo4j-core/relationship/relationship'
 require 'neo4j-core/relationship/class_methods'
 
@@ -40,8 +53,6 @@ require 'neo4j-core/node/class_methods'
 
 require 'neo4j/transaction'
 
-require 'neo4j-core/type_converters/type_converters'
-
 require 'neo4j-core/traversal/evaluator'
 require 'neo4j-core/traversal/filter_predicate'
 require 'neo4j-core/traversal/prune_evaluator'
@@ -49,5 +60,11 @@ require 'neo4j-core/traversal/rel_expander'
 require 'neo4j-core/traversal/traversal'
 require 'neo4j-core/traversal/traverser'
 
+require 'neo4j-core/cypher/cypher'
+require 'neo4j-core/cypher/result_wrapper'
+require 'neo4j-core/hash_with_indifferent_access'
+
+require 'neo4j/algo'
+require 'neo4j/cypher'
 require 'neo4j/node'
-require 'neo4j/relationship'
+require 'neo4j/relationship'

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

@@ -0,0 +1,1033 @@
+module Neo4j
+  module Core
+
+    # This module contains a number of mixins and classes used by the neo4j.rb cypher DSL.
+    # The Cypher DSL is evaluated in the context of {Neo4j::Cypher} which contains a number of methods (e.g. {Neo4j::Cypher#node})
+    # which returns classes from this module.
+    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
+
+        # @private
+        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
+
+        # generates a <tt>ID</tt> cypher fragment.
+        def neo_id
+          Property.new(@expressions, self, 'ID').to_function!
+        end
+
+        # generates a <tt>has</tt> cypher fragment.
+        def property?(p)
+          p = Property.new(expressions, self, p)
+          p.binary_operator("has")
+        end
+
+        # generates a <tt>is null</tt> cypher fragment.
+        def exist?
+          p = Property.new(expressions, self, p)
+          p.binary_operator("", " is null")
+        end
+
+        # Can be used instead of [_classname] == klass
+        def is_a?(klass)
+          return super if klass.class != Class || !klass.respond_to?(:_load_wrapper)
+          self[:_classname] == klass.to_s
+        end
+
+        def count
+          #expressions.delete(self)
+          ExprOp.new(self, nil, 'count')
+        end
+      end
+
+      module Matchable
+
+        def where(&block)
+          x = block.call(self)
+          expressions.delete(x)
+          ExprOp.new(x, nil, "").binary!
+          self
+        end
+
+        def where_not(&block)
+          x = block.call(self)
+          expressions.delete(x)
+          ExprOp.new(x, nil, "not").binary!
+          self
+        end
+
+
+        # 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
+
+        def outgoing(rel_type)
+          node = NodeVar.new(@expressions, @variables)
+          MatchRelLeft.new(self, ":`#{rel_type}`", expressions, :outgoing) > node
+          node
+        end
+
+        def incoming(rel_type)
+          node = NodeVar.new(@expressions, @variables)
+          MatchRelLeft.new(self, ":`#{rel_type}`", expressions, :incoming) < node
+          node
+        end
+
+        def both(rel_type)
+          node = NodeVar.new(@expressions, @variables)
+          MatchRelLeft.new(self, ":`#{rel_type}`", expressions, :both) < node
+          node
+        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)
+          curr_clause = clause
+          while (i = @expressions.reverse.index { |e| e.clause == curr_clause }).nil? && curr_clause != :start
+            curr_clause = prev_clause(curr_clause)
+          end
+
+          if i.nil?
+            @expressions << self
+          else
+            pos = @expressions.size - i
+            @expressions.insert(pos, self)
+          end
+        end
+
+        def prev_clause(clause)
+          {:limit => :skip, :skip => :order_by, :order_by => :return, :return => :where, :where => :match, :match => :start}[clause]
+        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
+
+      # A property is returned from a Variable by using the [] operator.
+      #
+      # It has a number of useful method like
+      # <tt>count</tt>, <tt>sum</tt>, <tt>avg</tt>, <tt>min</tt>, <tt>max</tt>, <tt>collect</tt>, <tt>head</tt>, <tt>last</tt>, <tt>tail</tt>,
+      #
+      # @example
+      #  n=node(2, 3, 4); n[:name].collect
+      #  # same as START n0=node(2,3,4) RETURN collect(n0.property)
+      class Property
+        # @private
+        attr_reader :expressions, :var_name, :var_expr
+        include Comparable
+        include MathOperator
+        include MathFunctions
+        include PredicateMethods
+
+        def initialize(expressions, var_expr, prop_name)
+          @var_expr = var_expr
+          @var = var_expr.respond_to?(:var_name) ? var_expr.var_name : var_expr
+          @expressions = expressions
+          @prop_name = prop_name
+          @var_name = @prop_name ? "#{@var.to_s}.#{@prop_name}" : @var.to_s
+        end
+
+        # @private
+        def to_function!(var = @var.to_s)
+          @var_name = "#{@prop_name}(#{var})"
+          self
+        end
+
+        # Make it possible to rename a property with a different name (AS)
+        def as(new_name)
+          @var_name = "#{@var_name} AS #{new_name}"
+        end
+
+        # required by the Predicate Methods Module
+        # @see PredicateMethods
+        # @private
+        def iterable
+          var_name
+        end
+
+        def input
+          self
+        end
+
+        # @private
+        def in?(values)
+          binary_operator("", " IN [#{values.map { |x| %Q["#{x}"] }.join(',')}]")
+        end
+
+        # Only return distinct values/nodes/rels/paths
+        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
+
+        # @private
+        def function(func_name_pre, func_name_post = "")
+          ExprOp.new(self, nil, func_name_pre, func_name_post)
+        end
+
+        # @private
+        def binary_operator(op, post_fix = "")
+          ExprOp.new(self, nil, op, post_fix).binary!
+        end
+      end
+
+      class Start < Expression
+        # @private
+        attr_reader :var_name
+        include Variable
+        include Matchable
+
+        def initialize(var_name, expressions)
+          @var_name = "#{var_name}#{expressions.size}"
+          super(expressions, :start)
+        end
+
+      end
+
+      # Can be created from a <tt>node</tt> dsl method.
+      class StartNode < Start
+        # @private
+        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
+
+
+      # Can be created from a <tt>rel</tt> dsl method.
+      class StartRel < Start
+        # @private
+        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
+
+        # @private
+        def return_method
+          @name_or_ref.respond_to?(:return_method) && @name_or_ref.return_method
+        end
+
+        # @private
+        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)
+          expressions.delete(props.first)
+          @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)
+          expressions.delete(props.first)
+          @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
+
+      # Can be used to skip result from a return clause
+      class Skip < Expression
+        def initialize(expressions, value)
+          super(expressions, :skip)
+          @value = value
+        end
+
+        def to_s
+          @value
+        end
+      end
+
+      # Can be used to limit result from a return clause
+      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)
+          @orders = []
+        end
+
+        def asc(props)
+          @orders << [:asc, props]
+        end
+
+        def desc(props)
+          @orders << [:desc, props]
+        end
+
+        def to_s
+          @orders.map do |pair|
+            if pair[0] == :asc
+              pair[1].map(&:var_name).join(', ')
+            else
+              pair[1].map(&:var_name).join(', ') + " DESC"
+            end
+          end.join(', ')
+        end
+      end
+
+      # Created from a node's match operator like >> or <.
+      class Match < Expression
+        # @private
+        attr_reader :dir, :expressions, :left, :right, :var_name, :dir_op
+        # @private
+        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
+
+
+        # Generates a <tt>x in nodes(m3)</tt> cypher expression.
+        #
+        # @example
+        #   p.nodes.all? { |x| x[:age] > 30 }
+        def nodes
+          Entities.new(@expressions, "nodes", self)
+        end
+
+        # Generates a <tt>x in relationships(m3)</tt> cypher expression.
+        #
+        # @example
+        #   p.relationships.all? { |x| x[:age] > 30 }
+        def rels
+          Entities.new(@expressions, "relationships", self)
+        end
+
+        # returns the length of the path
+        def length
+          self.return_method = {:name => 'length', :bracket => true}
+          self
+        end
+
+        # @private
+        def find_match_start
+          c = self
+          while (c.prev) do
+            c = c.prev
+          end
+          c
+        end
+
+        # @private
+        def left_var_name
+          @left.respond_to?(:var_name) ? @left.var_name : @left.to_s
+        end
+
+        # @private
+        def right_var_name
+          @right.respond_to?(:var_name) ? @right.var_name : @right.to_s
+        end
+
+        # @private
+        def right_expr
+          c = @right
+          r = while (c)
+                break c.var_expr if c.respond_to?(:var_expr)
+                c = c.respond_to?(:left_expr) && c.left_expr
+              end || @right
+
+          r.respond_to?(:expr) ? r.expr : right_var_name
+        end
+
+        # @private
+        def referenced!
+          @referenced = true
+        end
+
+        # @private
+        def referenced?
+          !!@referenced
+        end
+
+        # @private
+        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
+
+      # The left part of a match clause, e.g. node < rel(':friends')
+      # Can return {MatchRelRight} using a match operator method.
+      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
+
+        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
+
+        # @return [String] a cypher string for this match.
+        def expr
+          "#{dir_op}(#{right_expr})"
+        end
+
+        # negate this match
+        def not
+          expressions.delete(self)
+          ExprOp.new(left, nil, "not").binary!
+        end
+
+        if RUBY_VERSION > "1.9.0"
+          eval %{
+             def !
+          expressions.delete(self)
+          ExprOp.new(left, nil, "not").binary!
+             end
+             }
+        end
+
+      end
+
+      # The right part of a match clause (node_b), e.g. node_a > rel(':friends') > node_b
+      #
+      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)
+          variables ||= []
+          @var_name = "v#{variables.size}"
+          variables << self
+          @variables = variables
+          @expressions = expressions
+        end
+
+        # @return [String] a cypher string for this node variable
+        def to_s
+          var_name
+        end
+
+        # @private
+        def expr
+          to_s
+        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] : ""
+          @auto_var_name = "v#{variables.size}"
+          @var_name = guess.empty? ? @auto_var_name : guess
+        end
+
+        def rel_type
+          Property.new(@expressions, self, 'type').to_function!
+        end
+
+        def [](p)
+          if @expr.to_s[0..0] == ':'
+            @var_name = @auto_var_name
+            @expr = "#{@var_name}#{@expr}"
+          end
+          super
+        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, :left_expr, :right_expr
+        include MathFunctions
+
+
+        def initialize(left_expr, right_expr, op, post_fix = "")
+          super(left_expr.expressions, :where)
+          @left_expr = left_expr
+          @right_expr = right_expr
+          @op = op
+          @post_fix = post_fix
+          self.expressions.delete(left_expr)
+          self.expressions.delete(right_expr)
+          @left = quote(left_expr)
+          if regexp?(right_expr)
+            @op = "=~"
+            @right = to_regexp(right_expr)
+          else
+            @right = right_expr && quote(right_expr)
+          end
+          @neg = nil
+        end
+
+        def separator
+          " and "
+        end
+
+        def quote(val)
+          if val.respond_to?(:var_name) && !val.kind_of?(Match)
+            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?
+          # 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