nobrainer 0.22.0 → 0.28.0

data/lib/no_brainer/criteria/order_by.rb

@@ -2,7 +2,8 @@ module NoBrainer::Criteria::OrderBy
   extend ActiveSupport::Concern
 
   # The latest order_by() wins
-  included { criteria_option :order_by, :ordering_mode, :merge_with => :set_scalar }
+  included { criteria_option :order_by, :ordering_mode, :reversed_ordering,
+                             :merge_with => :set_scalar }
 
   def order_by(*rules, &block)
     # Note: We are relying on the fact that Hashes are ordered (since 1.9)
@@ -17,7 +18,10 @@ module NoBrainer::Criteria::OrderBy
       end
     end.reduce({}, :merge)
 
-    chain(:order_by => rules, :ordering_mode => :normal)
+    rules.keys.each { |k| model.ensure_valid_key!(k) unless k.is_a?(Proc) } if model
+
+    chain(:order_by => rules, :ordering_mode => :explicit,
+                              :reversed_ordering => false)
   end
 
   def without_ordering
@@ -25,12 +29,7 @@ module NoBrainer::Criteria::OrderBy
   end
 
   def reverse_order
-    chain(:ordering_mode => case @options[:ordering_mode]
-                            when nil       then :reversed
-                            when :normal   then :reversed
-                            when :reversed then :normal
-                            when :disabled then :disabled
-                            end)
+    chain(:reversed_ordering => !@options[:reversed_ordering])
   end
 
   def order_by_indexed?
@@ -43,16 +42,21 @@ module NoBrainer::Criteria::OrderBy
 
   private
 
-  def effective_order
-    @options[:order_by].presence || (model ? {model.pk_name => :asc} : {})
+  def ordering_mode
+    @options[:ordering_mode] || :implicit
   end
 
   def reverse_order?
-    @options[:ordering_mode] == :reversed
+    !!@options[:reversed_ordering]
   end
 
-  def should_order?
-    @options[:ordering_mode] != :disabled
+  def effective_order
+    # reversing the order happens later.
+    case ordering_mode
+    when :disabled then nil
+    when :explicit then @options[:order_by]
+    when :implicit then model && {model.pk_name => :asc}
+    end
   end
 
   class IndexFinder < Struct.new(:criteria, :index_name, :rql_proc)
@@ -61,7 +65,7 @@ module NoBrainer::Criteria::OrderBy
     end
 
     def first_key
-      @first_key ||= criteria.__send__(:effective_order).first.try(:[], 0)
+      @first_key ||= criteria.__send__(:effective_order).to_a.first.try(:[], 0)
     end
 
     def first_key_indexable?
@@ -94,9 +98,8 @@ module NoBrainer::Criteria::OrderBy
 
   def compile_rql_pass1
     rql = super
-    return rql unless should_order?
     _effective_order = effective_order
-    return rql if _effective_order.empty?
+    return rql unless _effective_order.present?
 
     rql_rules = _effective_order.map do |k,v|
       if order_by_index_finder.index_name == k

data/lib/no_brainer/criteria/run.rb

@@ -0,0 +1,26 @@
+module NoBrainer::Criteria::Run
+  extend ActiveSupport::Concern
+
+  included do
+    criteria_option :initial_run_options, :merge_with => :set_scalar
+    criteria_option :run_with, :merge_with => :merge_hash
+  end
+
+  private
+
+  def run(&block)
+    return finalized_criteria.__send__(:run, &block) unless finalized?
+    ensure_same_run_option_context!
+
+    block ||= proc { to_rql }
+    NoBrainer.run(:criteria => self, &block)
+  end
+
+  def ensure_same_run_option_context!
+    return if @options[:initial_run_options].nil?
+    return if @options[:initial_run_options] == NoBrainer.current_run_options
+
+    raise "The current criteria cannot be executed as it was constructed in a different `run_with()' context\n" +
+          "Note: you may use `run_with()' directly in your query (e.g. Model.run_with(...).first)."
+  end
+end

data/lib/no_brainer/criteria/scope.rb

@@ -3,10 +3,6 @@ module NoBrainer::Criteria::Scope
 
   included { criteria_option :use_default_scope, :merge_with => :set_scalar }
 
-  def scoped
-    chain(:use_default_scope => true)
-  end
-
   def unscoped
     chain(:use_default_scope => false)
   end
@@ -17,21 +13,25 @@ module NoBrainer::Criteria::Scope
 
   def method_missing(name, *args, &block)
     return super unless self.model.respond_to?(name)
+    apply_named_scope(name, args, block)
+  end
+
+  private
+
+  def apply_named_scope(name, args, block)
     criteria = self.model.method(name).call(*args, &block)
     raise "#{name} did not return a criteria" unless criteria.is_a?(NoBrainer::Criteria)
     merge(criteria)
   end
 
-  private
-
-  def _apply_default_scope
+  def apply_default_scope
     return self if @options[:use_default_scope] == false
     (model.default_scopes.map(&:call).compact + [self]).reduce(:merge)
   end
 
   module ClassMethods
     def _finalize_criteria(base)
-      super.__send__(:_apply_default_scope)
+      super.__send__(:apply_default_scope)
     end
   end
 end

data/lib/no_brainer/criteria/where.rb

@@ -1,12 +1,4 @@
 module NoBrainer::Criteria::Where
-  NON_CHAINABLE_OPERATORS = %w(in nin eq ne not gt ge gte lt le lte defined near intersects).map(&:to_sym)
-  CHAINABLE_OPERATORS = %w(any all).map(&:to_sym)
-  OPERATORS = CHAINABLE_OPERATORS + NON_CHAINABLE_OPERATORS
-
-  require 'symbol_decoration'
-  Symbol::Decoration.register(*NON_CHAINABLE_OPERATORS)
-  Symbol::Decoration.register(*CHAINABLE_OPERATORS, :chainable => true)
-
   extend ActiveSupport::Concern
   include ActiveModel::ForbiddenAttributesProtection
 
@@ -19,6 +11,10 @@ module NoBrainer::Criteria::Where
     chain(:where_ast => parse_clause([*args, block].compact))
   end
 
+  def _where(*args, &block)
+    chain(:where_ast => parse_clause([*args, block].compact, :unsafe => true))
+  end
+
   def self.merge_where_ast(a, b)
     (a ? MultiOperator.new(:and, [a, b]) : b).simplify
   end
@@ -57,7 +53,7 @@ module NoBrainer::Criteria::Where
       same_op_clauses, other_clauses = clauses.partition do |v|
         v.is_a?(self.class) && (v.clauses.size == 1 || v.op == self.op)
       end
-      simplified_clauses = other_clauses + same_op_clauses.map(&:clauses).flatten(1)
+      simplified_clauses = other_clauses + same_op_clauses.flat_map(&:clauses)
       simplified_clauses = BinaryOperator.simplify_clauses(op, simplified_clauses.uniq)
       self.class.new(op, simplified_clauses)
     end
@@ -70,7 +66,7 @@ module NoBrainer::Criteria::Where
     end
   end
 
-  class BinaryOperator < Struct.new(:key, :key_modifier, :op, :value, :model, :casted_values)
+  class BinaryOperator < Struct.new(:key_path, :key_modifier, :op, :value, :model, :casted_values)
     def self.get_candidate_clauses(clauses, *types)
       clauses.select { |c| c.is_a?(self) && types.include?(c.op) }
     end
@@ -79,10 +75,10 @@ module NoBrainer::Criteria::Where
       # This code assumes that simplfy() has already been called on all clauses.
       if op == :or
         eq_clauses = get_candidate_clauses(ast_clauses, :in, :eq)
-        new_clauses = eq_clauses.group_by { |c| [c.key, c.key_modifier] }.map do |(key, key_modifier), clauses|
+        new_clauses = eq_clauses.group_by { |c| [c.key_path, c.key_modifier] }.map do |(key_path, key_modifier), clauses|
           if key_modifier.in?([:scalar, :any]) && clauses.size > 1
-            values = clauses.map { |c| c.op == :in ? c.value : [c.value] }.flatten(1).uniq
-            [BinaryOperator.new(key, key_modifier, :in, values, clauses.first.model, true)]
+            values = clauses.flat_map { |c| c.op == :in ? c.value : [c.value] }.uniq
+            [BinaryOperator.new(key_path, key_modifier, :in, values, clauses.first.model, true)]
           else
             clauses
           end
@@ -97,30 +93,33 @@ module NoBrainer::Criteria::Where
     end
 
     def simplify
-      new_key = cast_key(key)
-      new_op, new_value = case op
+      new_key_path = cast_key_path(key_path)
+      new_key_modifier, new_op, new_value = case op
         when :in then
           case value
-          when Range then [:between, (cast_value(value.min)..cast_value(value.max))]
-          when Array then [:in, value.map(&method(:cast_value)).uniq]
+          when Range then [key_modifier, :between, (cast_value(value.min)..cast_value(value.max))]
+          when Array then [key_modifier, :in, value.map(&method(:cast_value)).uniq]
           else raise ArgumentError.new "`in' takes an array/range, not #{value}"
           end
-        when :between then [op, (cast_value(value.min)..cast_value(value.max))]
-        when :defined
-          raise "Incorrect use of `#{op}' and `#{key_modifier}'" if key_modifier != :scalar
-          [op, cast_value(value)]
-        else [op, cast_value(value)]
+        when :between then [key_modifier, op, (cast_value(value.min)..cast_value(value.max))]
+        when :include then ensure_scalar_for(op); [:any, :eq, cast_value(value)]
+        when :defined, :undefined then ensure_scalar_for(op); [key_modifier, op, cast_value(value)]
+        else [key_modifier, op, cast_value(value)]
       end
-      BinaryOperator.new(new_key, key_modifier, new_op, new_value, model, true)
+      BinaryOperator.new(new_key_path, new_key_modifier, new_op, new_value, model, true)
     end
 
     def to_rql(doc)
-      key = model.lookup_field_alias(self.key)
+      key_path = [model.lookup_field_alias(self.key_path.first), *self.key_path[1..-1]]
+
+      doc = key_path[0..-2].reduce(doc) { |d,k| d[k] }
+      key = key_path.last
 
       case key_modifier
       when :scalar then
         case op
-        when :defined then value ? doc.has_fields(key) : doc.has_fields(key).not
+        when :defined   then  value ? doc.has_fields(key) : doc.has_fields(key).not
+        when :undefined then !value ? doc.has_fields(key) : doc.has_fields(key).not
         else to_rql_scalar(doc[key])
         end
       when :any then doc[key].map { |lvalue| to_rql_scalar(lvalue) }.contains(true)
@@ -134,12 +133,9 @@ module NoBrainer::Criteria::Where
       when :in         then RethinkDB::RQL.new.expr(value).contains(lvalue)
       when :intersects then lvalue.intersects(value.to_rql)
       when :near
-        options = value.dup
-        point = options.delete(:point)
-        max_dist = options.delete(:max_dist)
-        # XXX max_results is not used, seems to be a workaround of rethinkdb index implemetnation.
-        _ = options.delete(:max_results)
-        RethinkDB::RQL.new.distance(lvalue, point.to_rql, options) <= max_dist
+        # XXX options[:max_results] is not used, seems to be a workaround of rethinkdb index implementation.
+        circle = value[:circle]
+        RethinkDB::RQL.new.distance(lvalue, circle.center.to_rql, circle.options) <= circle.radius
       else lvalue.__send__(op, value)
       end
     end
@@ -150,11 +146,13 @@ module NoBrainer::Criteria::Where
 
     private
 
+    def ensure_scalar_for(op)
+      raise "Incorrect use of `#{op}' and `#{key_modifier}'" if key_modifier != :scalar
+    end
+
     def association
-      # FIXME This leaks memory with dynamic attributes. The internals of type
-      # checking will convert the key to a symbol, and Ruby does not garbage
-      # collect symbols.
-      @association ||= [model.association_metadata[key.to_sym]]
+      return nil if key_path.size > 1
+      @association ||= [model.association_metadata[key_path.first]]
       @association.first
     end
 
@@ -165,61 +163,75 @@ module NoBrainer::Criteria::Where
       when NoBrainer::Document::Association::BelongsTo::Metadata
         target_model = association.target_model
         unless value.is_a?(target_model)
-          opts = { :model => model, :attr_name => key, :type => target_model, :value => value }
+          opts = { :model => model, :attr_name => key_path.first, :type => target_model, :value => value }
           raise NoBrainer::Error::InvalidType.new(opts)
         end
         value.pk_value
       else
         case op
-        when :defined then NoBrainer::Boolean.nobrainer_cast_user_to_model(value)
+        when :defined, :undefined then NoBrainer::Boolean.nobrainer_cast_user_to_model(value)
         when :intersects
           raise "Use a geo object with `intersects`" unless value.is_a?(NoBrainer::Geo::Base)
           value
         when :near
-          raise "Incorrect use of `near': rvalue must be a hash" unless value.is_a?(Hash)
-          options = NoBrainer::Geo::Base.normalize_geo_options(value)
-
-          unless options[:point] && options[:max_dist]
-            raise "`near' takes something like {:point => P, :max_distance => d}"
-          end
-
-          unless options[:point].is_a?(NoBrainer::Geo::Point)
-            options[:point] = NoBrainer::Geo::Point.nobrainer_cast_user_to_model(options[:point])
+          # TODO enforce key is a geo type
+          case value
+          when Hash
+            options = NoBrainer::Geo::Base.normalize_geo_options(value)
+
+            options[:radius] = options.delete(:max_distance) if options[:max_distance]
+            options[:radius] = options.delete(:max_dist) if options[:max_dist]
+            options[:center] = options.delete(:point) if options[:point]
+
+            unless options[:circle]
+              unless options[:center] && options[:radius]
+                raise "`near' takes something like {:center => P, :radius => d}"
+              end
+              { :circle => NoBrainer::Geo::Circle.new(options), :max_results => options[:max_results] }
+            end
+          when NoBrainer::Geo::Circle then { :circle => value }
+          else raise "Incorrect use of `near': rvalue must be a hash or a circle"
           end
-
-          options
         else
-          case key_modifier
-          when :scalar    then model.cast_user_to_db_for(key, value)
-          when :any, :all then model.cast_user_to_db_for(key, [value]).first
-          end
+          # 1) Box value in array if we have an any/all modifier
+          # 2) Box value in hash if we have a nested query.
+          value = [value] if key_modifier.in?([:any, :all])
+          value_hash = key_path.reverse.reduce(value) { |v,k| {k => v} }
+          value = model.cast_user_to_db_for(*value_hash.first)
+          value = key_path[1..-1].reduce(value) { |h,k| h[k] }
+          value = value.first if key_modifier.in?([:any, :all])
+          value
         end
       end
     end
 
-    def cast_key(key)
+    def cast_key_path(key)
       return key if casted_values
 
       case association
-      when NoBrainer::Document::Association::BelongsTo::Metadata then association.foreign_key
-      else ensure_valid_key!(key); key
+      when NoBrainer::Document::Association::BelongsTo::Metadata then [association.foreign_key]
+      else model.ensure_valid_key!(key_path.first); key_path
       end
     end
-
-    def ensure_valid_key!(key)
-      return if model.has_field?(key) || model.has_index?(key) || model < NoBrainer::Document::DynamicAttributes
-      raise NoBrainer::Error::UnknownAttribute, "`#{key}' is not a declared attribute of #{model}"
-    end
   end
 
-  class UnaryOperator < Struct.new(:op, :value)
+  class UnaryOperator < Struct.new(:op, :clause)
     def simplify
-      value.is_a?(UnaryOperator) && [self.op, value.op] == [:not, :not] ? value.value : self
+      simplified_clause = self.clause.simplify
+
+      case simplified_clause
+      when UnaryOperator then
+        case [self.op, simplified_clause.op]
+        when [:not, :not] then simplified_clause.clause
+        else self.class.new(op, simplified_clause)
+        end
+      else self.class.new(op, simplified_clause)
+      end
     end
 
     def to_rql(doc)
       case op
-      when :not then value.to_rql(doc).not
+      when :not then clause.to_rql(doc).not
       end
     end
   end
@@ -234,60 +246,53 @@ module NoBrainer::Criteria::Where
     end
   end
 
-  def parse_clause(clause)
+  def parse_clause(clause, options={})
     clause = sanitize_for_mass_assignment(clause)
     case clause
-    when Array then MultiOperator.new(:and, clause.map { |c| parse_clause(c) })
-    when Hash  then MultiOperator.new(:and, clause.map { |k,v| parse_clause_stub(k,v) })
+    when Array then MultiOperator.new(:and, clause.map { |c| parse_clause(c, options) })
+    when Hash  then MultiOperator.new(:and, clause.map { |k,v| parse_clause_stub(k, v, options) })
     when Proc  then Lambda.new(clause)
     when Symbol::Decoration
       case clause.args.size
-      when 1 then parse_clause_stub(clause, clause.args.first)
+      when 1 then parse_clause_stub(clause, clause.args.first, options)
       else raise "Invalid argument: #{clause}"
       end
     else raise "Invalid clause: #{clause}"
     end
   end
 
-  def parse_clause_stub(key, value)
+  def parse_clause_stub(key, value, options={})
     case key
-    when :and  then parse_multi_value(:and, value)
-    when :or   then parse_multi_value(:or,  value)
-    when :_and then parse_multi_value(:and, value, :safe => true)
-    when :_or  then parse_multi_value(:or,  value, :safe => true)
-    when :not  then UnaryOperator.new(:not, parse_clause(value))
-    when String, Symbol then parse_clause_stub_eq(key, value)
+    when :and  then parse_multi_value(:and, value, false, options)
+    when :or   then parse_multi_value(:or,  value, false, options)
+    when :_and then parse_multi_value(:and, value, true, options)
+    when :_or  then parse_multi_value(:or,  value, true, options)
+    when :not  then UnaryOperator.new(:not, parse_clause(value, options))
+    when String, Symbol then
+      case value
+      when Hash then parse_clause(value, options.merge(:nested_prefix => (options[:nested_prefix] || []) + [key.to_sym]))
+      else instantiate_binary_op(key.to_sym, :eq, value, options)
+      end
     when Symbol::Decoration then
       case key.decorator
-      when :any, :all then parse_clause_stub_eq(key, value)
-      when :not, :ne  then parse_clause(:not => { key.symbol.eq => value })
-      when :nin then parse_clause(:not => { key.symbol.in => value })
-      when :gte then parse_clause(key.symbol.ge => value)
-      when :lte then parse_clause(key.symbol.le => value)
-      when :eq  then parse_clause_stub_eq(key.symbol, value)
-      else instantiate_binary_op(key.symbol, key.decorator, value)
+      when :any, :all, :not then instantiate_binary_op(key, :eq, value, options)
+      when :gte then instantiate_binary_op(key.symbol, :ge, value, options)
+      when :lte then instantiate_binary_op(key.symbol, :le, value, options)
+      else instantiate_binary_op(key.symbol, key.decorator, value, options)
       end
     else raise "Invalid key: #{key}"
     end
   end
 
-  def parse_multi_value(op, value, options={})
+  def parse_multi_value(op, value, multi_safe, options={})
     raise "The `#{op}' operator takes an array as argument" unless value.is_a?(Array)
-    if value.size == 1 && value.first.is_a?(Hash) && !options[:safe]
+    if value.size == 1 && value.first.is_a?(Hash) && !multi_safe
       raise "The `#{op}' operator was provided an array with a single hash element.\n" +
             "In Ruby, [:a => :b, :c => :d] means [{:a => :b, :c => :d}] which is not the same as [{:a => :b}, {:c => :d}].\n" +
             "To prevent mistakes, the former construct is prohibited as you probably mean the latter.\n" +
             "However, if you know what you are doing, you can use the `_#{op}' operator instead."
     end
-    MultiOperator.new(op, value.map { |v| parse_clause(v) })
-  end
-
-  def parse_clause_stub_eq(key, value)
-    case value
-    when Range  then instantiate_binary_op(key, :between, value)
-    when Regexp then instantiate_binary_op(key, :match, translate_regexp_to_re2_syntax(value))
-    else instantiate_binary_op(key, :eq, value)
-    end
+    MultiOperator.new(op, value.map { |v| parse_clause(v, options) })
   end
 
   def translate_regexp_to_re2_syntax(value)
@@ -303,10 +308,25 @@ module NoBrainer::Criteria::Where
     "(?#{flags})#{value.source}"
   end
 
-  def instantiate_binary_op(key, op, value)
+  def instantiate_binary_op(key, op, value, options={})
+    op, value = case value
+                when Range  then [:between, value]
+                when Regexp then [:match, translate_regexp_to_re2_syntax(value)]
+                else [:eq, value]
+                end if op == :eq
+
+    nested_prefix = options[:nested_prefix] || []
+
+    tail_args = [op, value, self.model, !!options[:unsafe]]
+
     case key
-    when Symbol::Decoration then BinaryOperator.new(key.symbol, key.decorator, op, value, self.model)
-    else BinaryOperator.new(key, :scalar, op, value, self.model)
+    when Symbol::Decoration
+      raise "Use only one .not, .all or .any modifiers in the query" if key.symbol.is_a?(Symbol::Decoration)
+      case key.decorator
+        when :any, :all then BinaryOperator.new(nested_prefix + [key.symbol], key.decorator, *tail_args)
+        when :not       then UnaryOperator.new(:not, BinaryOperator.new(nested_prefix + [key.symbol], :scalar, *tail_args))
+      end
+    else BinaryOperator.new(nested_prefix + [key], :scalar, *tail_args)
     end
   end
 
@@ -319,12 +339,12 @@ module NoBrainer::Criteria::Where
 
       def rql_proc
         lambda do |rql|
+          return RethinkDB::RQL.new.expr([]) if rql_op == :get_all && rql_args.empty?
+
           opt = (rql_options || {}).merge(:index => index.aliased_name)
           r = rql.__send__(rql_op, *rql_args, opt)
           r = r.map { |i| i['doc'] } if rql_op == :get_nearest
-          # TODO distinct: waiting for issue #3345
-          # TODO coerce_to: waiting for issue #3346
-          r = r.coerce_to('array').distinct if index.multi && !index_finder.criteria.options[:without_distinct]
+          r = r.distinct if index.multi && !index_finder.criteria.options[:without_distinct]
           r
         end
       end
@@ -347,9 +367,9 @@ module NoBrainer::Criteria::Where
       clauses = get_candidate_clauses(:eq, :in, :between, :near, :intersects)
       return nil unless clauses.present?
 
-      usable_indexes = Hash[get_usable_indexes.map { |i| [i.name, i] }]
+      usable_indexes = Hash[get_usable_indexes.map { |i| [[i.name], i] }]
       clauses.map do |clause|
-        index = usable_indexes[clause.key]
+        index = usable_indexes[clause.key_path]
         next unless index && clause.compatible_with_index?(index)
         next unless index.geo == [:near, :intersects].include?(clause.op)
 
@@ -357,8 +377,10 @@ module NoBrainer::Criteria::Where
           when :intersects then [:get_intersecting, clause.value.to_rql]
           when :near
             options = clause.value.dup
-            point = options.delete(:point)
-            [:get_nearest, point.to_rql, options]
+            circle = options.delete(:circle)
+            options.delete(:max_results) if options[:max_results].nil?
+            options[:max_dist] = circle.radius
+            [:get_nearest, circle.center.to_rql, circle.options.merge(options)]
           when :eq      then [:get_all, [clause.value]]
           when :in      then [:get_all, clause.value]
           when :between then [:between, [clause.value.min, clause.value.max],
@@ -369,11 +391,11 @@ module NoBrainer::Criteria::Where
     end
 
     def find_strategy_compound
-      clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key, c] }]
+      clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key_path, c] }]
       return nil unless clauses.present?
 
       get_usable_indexes(:kind => :compound, :geo => false, :multi => false).each do |index|
-        indexed_clauses = index.what.map { |field| clauses[field] }
+        indexed_clauses = index.what.map { |field| clauses[[field]] }
         next unless indexed_clauses.all? { |c| c.try(:compatible_with_index?, index) }
 
         return IndexStrategy.new(self, ast, indexed_clauses, index, :get_all, [indexed_clauses.map(&:value)])
@@ -382,11 +404,11 @@ module NoBrainer::Criteria::Where
     end
 
     def find_strategy_hidden_between
-      clauses = get_candidate_clauses(:gt, :ge, :lt, :le).group_by(&:key)
+      clauses = get_candidate_clauses(:gt, :ge, :lt, :le).group_by(&:key_path)
       return nil unless clauses.present?
 
       get_usable_indexes(:geo => false).each do |index|
-        matched_clauses = clauses[index.name].try(:select) { |c| c.compatible_with_index?(index) }
+        matched_clauses = clauses[[index.name]].try(:select) { |c| c.compatible_with_index?(index) }
         next unless matched_clauses.present?
 
         op_clauses = Hash[matched_clauses.map { |c| [c.op, c] }]
@@ -401,7 +423,8 @@ module NoBrainer::Criteria::Where
         options[:right_bound] = {:lt => :open, :le => :closed}[right_bound.op] if right_bound
 
         return IndexStrategy.new(self, ast, [left_bound, right_bound].compact, index, :between,
-                                 [left_bound.try(:value), right_bound.try(:value)], options)
+                                 [left_bound  ? left_bound.try(:value)  : RethinkDB::RQL.new.minval,
+                                  right_bound ? right_bound.try(:value) : RethinkDB::RQL.new.maxval], options)
       end
       return nil
     end

data/lib/no_brainer/criteria.rb

@@ -2,8 +2,8 @@ require 'rethinkdb'
 
 class NoBrainer::Criteria
   extend NoBrainer::Autoload
-  autoload_and_include :Core, :Raw, :AfterFind, :Where, :OrderBy, :Limit,
-                       :Pluck, :Count, :Delete, :Enumerable, :First, :Find,
-                       :Aggregate, :EagerLoad, :Update, :Cache, :Index,
-                       :Extend, :Scope
+  autoload_and_include :Core, :Run, :Raw, :Scope, :AfterFind, :Where, :OrderBy,
+                       :Limit, :Pluck, :Count, :Delete, :Enumerable, :Find,
+                       :First, :FirstOrCreate, :Changes, :Aggregate, :EagerLoad,
+                       :Update, :Cache, :Index, :Extend, :Join
 end