nobrainer 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e97dd4f563340a2c8551ffefb21f22fc628954b2
-  data.tar.gz: 1fca054e8f966be9e7518f8245c39987d40068c7
+  metadata.gz: fe36d41b56c9780a4d16f3085d31de0361d34cae
+  data.tar.gz: 9f89b0da1f34d65c8861345307adc79f93a5593d
 SHA512:
-  metadata.gz: 1cbfebfa6ac2922e733d157522eda4e6c9edf9de9e51601f6892ac2ac2814593ed20807c68441a2ff7391398cf37896eeb739eaf2cdafa0da8e9fe91bb02fce2
-  data.tar.gz: ace1719ae85c7593145e81818fb1b93f715ad65d4634130c664b0fdd134c637aba0395066163b9fd3aee91f7ec0b27a53338e857ec2c089a4b425e02f2eba00b
+  metadata.gz: 43e0cf6f767028a46068635713cb9c1d639a8e03de6503493a6af05179977dfe1ae01b5c6a49d93ec0f2e4012a24b0386b6f66d31c7dd274ec05f5f69b252ba3
+  data.tar.gz: e728763fc6095d493db2ed93a9141f72d7cfc927f35300993f0ca6272996a5bac120f6f9cbfc9a985d80329a78da88ec5d827d5af31ccce93c833704b3a17f0b

data/lib/no_brainer/autoload.rb

@@ -15,11 +15,11 @@ module NoBrainer::Autoload
 
   def autoload_and_include(*constants)
     constants.each { |constant| autoload constant }
-    constants.each { |constant| include const_get constant }
+    constants.each { |constant| include const_get(constant) }
   end
 
   def eager_autoload_and_include(*constants)
     eager_autoload(*constants)
-    constants.each { |constant| include const_get constant }
+    constants.each { |constant| include const_get(constant) }
   end
 end

data/lib/no_brainer/criteria.rb

@@ -2,6 +2,7 @@ require 'rethinkdb'
 
 class NoBrainer::Criteria
   extend NoBrainer::Autoload
-  autoload_and_include :Core, :Scope, :Raw, :AfterFind, :Where, :OrderBy, :Limit,
-                       :Count, :Delete, :Enumerable, :First, :Preload, :Update, :Cache
+  autoload_and_include :Core, :Raw, :AfterFind, :Where, :OrderBy, :Limit,
+                       :Pluck, :Count, :Delete, :Enumerable, :First, :Aggregate,
+                       :Preload, :Update, :Cache, :Index, :Scope
 end

data/lib/no_brainer/criteria/after_find.rb

@@ -15,7 +15,7 @@ module NoBrainer::Criteria::AfterFind
     self
   end
 
-  def instantiate_doc(attrs)
+  def _instantiate_doc(attrs)
     super.tap do |doc|
       self._after_find.to_a.each { |block| block.call(doc) }
       doc.run_callbacks(:find) if doc.is_a?(NoBrainer::Document)

data/lib/no_brainer/criteria/aggregate.rb

@@ -0,0 +1,25 @@
+module NoBrainer::Criteria::Aggregate
+  extend ActiveSupport::Concern
+
+  def min(*a, &b)
+    instantiate_doc NoBrainer.run { aggregate_rql(:min, *a, &b) }
+  end
+
+  def max(*a, &b)
+    instantiate_doc NoBrainer.run { aggregate_rql(:max, *a, &b) }
+  end
+
+  def sum(*a, &b)
+    NoBrainer.run { aggregate_rql(:sum, *a, &b) }
+  end
+
+  def avg(*a, &b)
+    NoBrainer.run { aggregate_rql(:avg, *a, &b) }
+  end
+
+  private
+
+  def aggregate_rql(type, *a, &b)
+    without_ordering.without_plucking.to_rql.__send__(type, *klass.with_fields_aliased(a), &b)
+  end
+end

data/lib/no_brainer/criteria/core.rb

@@ -12,7 +12,7 @@ module NoBrainer::Criteria::Core
   end
 
   def to_rql
-    with_default_scope_applied.__send__(:compile_rql_pass2)
+    finalized_criteria.__send__(:compile_rql_pass2)
   end
 
   def inspect
@@ -56,4 +56,18 @@ module NoBrainer::Criteria::Core
     # This method is overriden by other modules.
     compile_rql_pass1
   end
+
+  def finalized?
+    !!init_options[:finalized]
+  end
+
+  def finalized_criteria
+    @finalized_criteria ||= finalized? ? self : self.class._finalize_criteria(self)
+  end
+
+  module ClassMethods
+    def _finalize_criteria(base)
+      base.merge(base.class.new(:finalized => true))
+    end
+  end
 end

data/lib/no_brainer/criteria/count.rb

@@ -2,7 +2,7 @@ module NoBrainer::Criteria::Count
   extend ActiveSupport::Concern
 
   def count
-    run(without_ordering.to_rql.count)
+    run(without_ordering.without_plucking.to_rql.count)
   end
 
   def empty?

data/lib/no_brainer/criteria/delete.rb

@@ -2,10 +2,10 @@ module NoBrainer::Criteria::Delete
   extend ActiveSupport::Concern
 
   def delete_all
-    run(without_ordering.to_rql.delete)
+    run(without_ordering.without_plucking.to_rql.delete)
   end
 
   def destroy_all
-    without_ordering.to_a.each { |doc| doc.destroy }
+    to_a.each { |doc| doc.destroy }
   end
 end

data/lib/no_brainer/criteria/index.rb

@@ -0,0 +1,37 @@
+module NoBrainer::Criteria::Index
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :with_index_name }
+
+  def with_index(index_name=true)
+    chain { |criteria| criteria.with_index_name = index_name }
+  end
+
+  def without_index
+    with_index(false)
+  end
+
+  def without_index?
+    finalized_criteria.with_index_name == false
+  end
+
+  def used_index
+    # only one of them will be active.
+    where_index_name || order_by_index_name
+  end
+
+  def merge!(criteria, options={})
+    super
+    self.with_index_name = criteria.with_index_name unless criteria.with_index_name.nil?
+    self
+  end
+
+  def compile_rql_pass2
+    super.tap do
+      if with_index_name && (!used_index || order_by_index_name.to_s == klass.pk_name.to_s)
+        # The implicit ordering on the indexed pk does not count.
+        raise NoBrainer::Error::CannotUseIndex.new(with_index_name)
+      end
+    end
+  end
+end

data/lib/no_brainer/criteria/order_by.rb

@@ -16,8 +16,7 @@ module NoBrainer::Criteria::OrderBy
         bad_rule = rule.values.reject { |v| v.in? [:asc, :desc] }.first
         raise_bad_rule(bad_rule) if bad_rule
         rule
-      when Symbol then { rule => :asc }
-      when Proc   then { rule => :asc }
+      when String, Symbol, Proc then { rule => :asc }
       else raise_bad_rule(rule)
       end
     end.reduce({}, :merge)
@@ -52,6 +51,14 @@ module NoBrainer::Criteria::OrderBy
     end
   end
 
+  def order_by_indexed?
+    !!order_by_index_name
+  end
+
+  def order_by_index_name
+    order_by_index_finder.index_name
+  end
+
   private
 
   def effective_order
@@ -66,6 +73,41 @@ module NoBrainer::Criteria::OrderBy
     self.ordering_mode != :disabled
   end
 
+  class IndexFinder < Struct.new(:criteria, :index_name, :rql_proc)
+    def could_find_index?
+      !!self.index_name
+    end
+
+    def first_key
+      @first_key ||= criteria.__send__(:effective_order).first.try(:[], 0)
+    end
+
+    def first_key_indexable?
+      (first_key.is_a?(Symbol) || first_key.is_a?(String)) && criteria.klass.has_index?(first_key)
+    end
+
+    def find_index
+      return if criteria.without_index?
+      return unless first_key_indexable?
+
+      if criteria.with_index_name && criteria.with_index_name != true
+        return unless first_key.to_s == criteria.with_index_name.to_s
+      end
+
+      # We need make sure that the where index finder has been invoked, it has priority.
+      # If it doesn't find anything, we are free to go with our indexes.
+      if !criteria.where_indexed? || (criteria.where_index_type == :between &&
+                                      first_key.to_s == criteria.where_index_name.to_s)
+        self.index_name = first_key
+      end
+    end
+  end
+
+  def order_by_index_finder
+    return finalized_criteria.__send__(:order_by_index_finder) unless finalized?
+    @order_by_index_finder ||= IndexFinder.new(self).tap { |index_finder| index_finder.find_index }
+  end
+
   def compile_rql_pass1
     rql = super
     return rql unless should_order?
@@ -73,6 +115,12 @@ module NoBrainer::Criteria::OrderBy
     return rql if _effective_order.empty?
 
     rql_rules = _effective_order.map do |k,v|
+      if order_by_index_finder.index_name == k
+        k = klass.lookup_index_alias(k)
+      else
+        k = klass.lookup_field_alias(k)
+      end
+
       case v
       when :asc  then reverse_order? ? RethinkDB::RQL.new.desc(k) : RethinkDB::RQL.new.asc(k)
       when :desc then reverse_order? ? RethinkDB::RQL.new.asc(k)  : RethinkDB::RQL.new.desc(k)
@@ -82,19 +130,11 @@ module NoBrainer::Criteria::OrderBy
     # We can only apply an index order_by on a table() term.
     # We are going to try to go so and if we cannot, we'll simply apply
     # the ordering in pass2, which will happen after a potential filter().
-
-    NoBrainer::RQL.is_table?(rql)
-    if NoBrainer::RQL.is_table?(rql) && !without_index?
-      options = {}
-      first_key = _effective_order.first[0]
-      if (first_key.is_a?(Symbol) || first_key.is_a?(String)) && klass.has_index?(first_key)
-        options[:index] = rql_rules.shift
-      end
-
+    if order_by_index_finder.could_find_index?
+      options = { :index => rql_rules.shift }
       rql = rql.order_by(*rql_rules, options)
     else
-      # Stashing @rql_rules for pass2, which is a pretty gross hack.
-      # We should really use more of a middleware pattern to build the RQL.
+      # Stashing @rql_rules for pass2
       @rql_rules_pass2 = rql_rules
     end
 

data/lib/no_brainer/criteria/pluck.rb

@@ -0,0 +1,81 @@
+module NoBrainer::Criteria::Pluck
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :missing_attributes }
+
+  def pluck(*attrs)
+    _missing_attributes_criteria(:pluck, attrs)
+  end
+
+  def without(*attrs)
+    _missing_attributes_criteria(:without, attrs)
+  end
+
+  def lazy_fetch(*attrs)
+    _missing_attributes_criteria(:lazy_fetch, attrs)
+  end
+
+  def without_plucking
+    chain { |criteria| criteria.missing_attributes = :remove }
+  end
+
+  def merge!(criteria, options={})
+    return super unless criteria.missing_attributes
+
+    if criteria.missing_attributes == :remove
+      self.missing_attributes = nil
+    else
+      self.missing_attributes ||= {}
+      criteria.missing_attributes.each do |type, attrs|
+        old_attrs = self.missing_attributes[type] || {}.with_indifferent_access
+        new_attrs = old_attrs.deep_merge(attrs)
+        self.missing_attributes[type] = new_attrs
+      end
+    end
+
+    self
+  end
+
+  private
+
+  def _missing_attributes_criteria(type, args)
+    raise ArgumentError if args.size.zero?
+    args = [Hash[args.flatten.map { |k| [k, true] }]] unless args.size == 1 && args.first.is_a?(Hash)
+    chain { |criteria| criteria.missing_attributes = {type => args.first} }
+
+  end
+
+  def effective_missing_attributes
+    return nil if self.missing_attributes.nil?
+    @effective_missing_attributes ||= begin
+      # pluck gets priority
+
+      missing_attributes = Hash[self.missing_attributes.map do |type, attrs|
+        attrs = attrs.select { |k,v| v } # TODO recursive
+        attrs.empty? ? nil : [type, attrs]
+      end.compact]
+
+      if missing_attributes[:pluck]
+        { :pluck => missing_attributes[:pluck] }
+      else
+        attrs = [missing_attributes[:without], missing_attributes[:lazy_fetch]].compact.reduce(&:merge)
+        { :without => attrs } if attrs.present?
+      end
+    end
+  end
+
+  def _instantiate_model(attrs, options={})
+    return super if missing_attributes.nil?
+    super(attrs, options.merge(:missing_attributes => effective_missing_attributes,
+                               :lazy_fetch => missing_attributes[:lazy_fetch]))
+  end
+
+  def compile_rql_pass2
+    rql = super
+    if effective_missing_attributes
+      type, attrs = effective_missing_attributes.first
+      rql = rql.__send__(type, klass.with_fields_aliased(attrs))
+    end
+    rql
+  end
+end

data/lib/no_brainer/criteria/raw.rb

@@ -13,13 +13,21 @@ module NoBrainer::Criteria::Raw
     self
   end
 
-  private
-
   def raw?
-    !!_raw
+    !!finalized_criteria._raw
   end
 
+  private
+
   def instantiate_doc(attrs)
-    raw? ? attrs : klass.new_from_db(attrs)
+    finalized_criteria._instantiate_doc(attrs)
+  end
+
+  def _instantiate_doc(attrs)
+    raw? ? attrs : _instantiate_model(attrs)
+  end
+
+  def _instantiate_model(attrs, options={})
+    klass.new_from_db(attrs, options)
   end
 end

data/lib/no_brainer/criteria/scope.rb

@@ -34,12 +34,17 @@ module NoBrainer::Criteria::Scope
     klass.default_scope_proc && use_default_scope != false
   end
 
-  def with_default_scope_applied
-    if should_apply_default_scope?
-      # XXX If default_scope.class != self.class, oops
-      klass.default_scope_proc.call.merge(self).unscoped
-    else
-      self
+  def _apply_default_scope
+    return unless should_apply_default_scope?
+    criteria = klass.default_scope_proc.call
+    raise "Mixing model issue. Contact developer." if [criteria.klass, self.klass].compact.uniq.size == 2
+    criteria.merge(self)
+  end
+
+  module ClassMethods
+    def _finalize_criteria(base)
+      criteria = super
+      criteria.__send__(:_apply_default_scope) || criteria
     end
   end
 end

data/lib/no_brainer/criteria/update.rb

@@ -1,11 +1,19 @@
 module NoBrainer::Criteria::Update
   extend ActiveSupport::Concern
 
-  def update_all(*args, &block)
-    run(without_ordering.to_rql.update(*args, &block))
+  def update_all(*a, &b)
+    prepare_args_for_update!(a)
+    run(without_ordering.without_plucking.to_rql.update(*a, &b))
   end
 
-  def replace_all(*args, &block)
-    run(without_ordering.to_rql.replace(*args, &block))
+  def replace_all(*a, &b)
+    prepare_args_for_update!(a)
+    run(without_ordering.without_plucking.to_rql.replace(*a, &b))
+  end
+
+  private
+
+  def prepare_args_for_update!(a)
+    a[0] = klass.persistable_attributes(a[0]) if !a.empty? && a.first.is_a?(Hash)
   end
 end

data/lib/no_brainer/criteria/where.rb

@@ -5,45 +5,60 @@ module NoBrainer::Criteria::Where
 
   def initialize(options={})
     super
-    self.where_ast = MultiOperator.new(:and, [])
   end
 
   def where(*args, &block)
     chain { |criteria| criteria.where_ast = parse_clause([*args, block].compact) }
   end
 
-  def with_index(index_name)
-    chain { |criteria| criteria.with_index_name = index_name }
+  def merge!(criteria, options={})
+    super
+
+    if criteria.where_ast
+      if self.where_ast
+        self.where_ast = MultiOperator.new(:and, [self.where_ast, criteria.where_ast])
+      else
+        self.where_ast = criteria.where_ast
+      end
+      self.where_ast = self.where_ast.simplify
+      raise unless criteria.where_ast.is_a?(MultiOperator)
+    end
+
+    self.with_index_name = criteria.with_index_name unless criteria.with_index_name.nil?
+    self
   end
 
-  def without_index
-    with_index(false)
+  def where_present?
+    finalized_criteria.where_ast.try(:clauses).present?
   end
 
-  def used_index
-    index_finder.index_name
+  def where_indexed?
+    !!where_index_name
   end
 
-  def indexed?
-    index_finder.could_find_index?
+  def where_index_name
+    where_index_finder.index_name
   end
 
-  def merge!(criteria, options={})
-    super
-    clauses = self.where_ast.clauses + criteria.where_ast.clauses
-    self.where_ast = MultiOperator.new(:and, clauses).simplify
-    self.with_index_name = criteria.with_index_name unless criteria.with_index_name.nil?
-    self
+  def where_index_type
+    where_index_finder.index_type
   end
 
   private
 
   class MultiOperator < Struct.new(:op, :clauses)
     def simplify
-      same_op_clauses, other_clauses = self.clauses.map(&:simplify)
-        .partition { |v| v.is_a?(MultiOperator) && self.op == v.op }
+      clauses = self.clauses.map(&:simplify)
+      if self.clauses.size == 1 && self.clauses.first.is_a?(self.class)
+        return clauses.first
+      end
+
+      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)
-      MultiOperator.new(op, simplified_clauses.uniq)
+      simplified_clauses =  BinaryOperator.simplify_clauses(op, simplified_clauses.uniq)
+      self.class.new(op, simplified_clauses)
     end
 
     def to_rql(doc)
@@ -54,22 +69,48 @@ module NoBrainer::Criteria::Where
     end
   end
 
-  class BinaryOperator < Struct.new(:key, :op, :value, :criteria, :casted_values)
+  class BinaryOperator < Struct.new(:key, :op, :value, :model, :casted_values)
+    def self.get_candidate_clauses(clauses, *types)
+      clauses.select { |c| c.is_a?(self) && types.include?(c.op) }
+    end
+
+    def self.simplify_clauses(op, ast_clauses)
+      # 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(&:key).map do |key, clauses|
+          case clauses.size
+          when 1 then clauses.first
+          else
+            values = clauses.map { |c| c.op == :in ? c.value : [c.value] }.flatten(1).uniq
+            BinaryOperator.new(key, :in, values, clauses.first.model, true)
+          end
+        end
+
+        if new_clauses.size != eq_clauses.size
+          ast_clauses = ast_clauses - eq_clauses + new_clauses
+        end
+      end
+
+      ast_clauses
+    end
+
     def simplify
       key = cast_key(self.key)
       case op
       when :in then
         case value
-        when Range then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), criteria, true)
-        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast_value)).uniq, criteria, true)
+        when Range then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), model, true)
+        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast_value)).uniq, model, true)
         else raise ArgumentError.new ":in takes an array/range, not #{value}"
         end
-      when :between then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), criteria, true)
-      else BinaryOperator.new(key, op, cast_value(value), criteria, true)
+      when :between then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), model, true)
+      else BinaryOperator.new(key, op, cast_value(value), model, true)
       end
     end
 
     def to_rql(doc)
+      key = model.lookup_field_alias(self.key)
       case op
       when :defined then value ? doc.has_fields(key) : doc.has_fields(key).not
       when :between then (doc[key] >= value.min) & (doc[key] <= value.max)
@@ -84,7 +125,7 @@ module NoBrainer::Criteria::Where
       # 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 ||= [criteria.klass.association_metadata[key.to_sym]]
+      @association ||= [model.association_metadata[key.to_sym]]
       @association.first
     end
 
@@ -98,7 +139,7 @@ module NoBrainer::Criteria::Where
         raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_klass)
         value.pk_value
       else
-        criteria.klass.cast_user_to_db_for(key, value)
+        model.cast_user_to_db_for(key, value)
       end
     end
 
@@ -106,10 +147,8 @@ module NoBrainer::Criteria::Where
       return key if casted_values
 
       case association
-      when NoBrainer::Document::Association::BelongsTo::Metadata
-        association.foreign_key
-      else
-        key
+      when NoBrainer::Document::Association::BelongsTo::Metadata then association.foreign_key
+      else key
       end
     end
   end
@@ -161,7 +200,7 @@ module NoBrainer::Criteria::Where
       when :nin then parse_clause(:not => { key.symbol.in => value })
       when :ne  then parse_clause(:not => { key.symbol.eq => value })
       when :eq  then parse_clause_stub_eq(key.symbol, value)
-      else BinaryOperator.new(key.symbol, key.modifier, value, self)
+      else BinaryOperator.new(key.symbol, key.modifier, value, self.klass)
       end
     else raise "Invalid key: #{key}"
     end
@@ -169,37 +208,40 @@ module NoBrainer::Criteria::Where
 
   def parse_clause_stub_eq(key, value)
     case value
-    when Range  then BinaryOperator.new(key, :between, value, self)
-    when Regexp then BinaryOperator.new(key, :match, value.inspect[1..-2], self)
-    else BinaryOperator.new(key, :eq, value, self)
+    when Range  then BinaryOperator.new(key, :between, value, self.klass)
+    when Regexp then BinaryOperator.new(key, :match, value.inspect[1..-2], self.klass)
+    else BinaryOperator.new(key, :eq, value, self.klass)
     end
   end
 
-  def without_index?
-    self.with_index_name == false
-  end
-
-  class IndexFinder < Struct.new(:criteria, :index_name, :rql_proc, :ast)
+  class IndexFinder < Struct.new(:criteria, :ast, :index_name, :index_type, :rql_proc)
     def initialize(*args)
       super
-      find_index
     end
 
     def could_find_index?
       !!self.index_name
     end
 
-    private
-
     def get_candidate_clauses(*types)
-      criteria.where_ast.clauses.select { |c| c.is_a?(BinaryOperator) && types.include?(c.op) }
+      BinaryOperator.get_candidate_clauses(ast.clauses, *types)
     end
 
     def get_usable_indexes(*types)
-      indexes = criteria.klass.indexes
-      indexes = indexes.select { |k,v| types.include?(v[:kind]) } if types.present?
-      indexes = indexes.select { |k,v| k == criteria.with_index_name.to_sym } if criteria.with_index_name
-      indexes
+      @usable_indexes = {}
+      @usable_indexes[types] ||= begin
+        indexes = criteria.klass.indexes
+        indexes = indexes.select { |k,v| types.include?(v[:kind]) } if types.present?
+        if criteria.with_index_name && criteria.with_index_name != true
+          indexes = indexes.select { |k,v| k == criteria.with_index_name.to_sym }
+        end
+        indexes
+      end
+    end
+
+    def remove_from_ast(clauses)
+      new_ast = MultiOperator.new(ast.op, ast.clauses - clauses)
+      return new_ast if new_ast.clauses.present?
     end
 
     def find_index_canonical
@@ -208,12 +250,14 @@ module NoBrainer::Criteria::Where
 
       if index_name = (get_usable_indexes.keys & clauses.keys).first
         clause = clauses[index_name]
+        aliased_index = criteria.klass.indexes[index_name][:as]
         self.index_name = index_name
-        self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - [clause])
+        self.ast = remove_from_ast([clause])
+        self.index_type = clause.op == :between ? :between : :get_all
         self.rql_proc = case clause.op
-          when :eq      then ->(rql){ rql.get_all(clause.value, :index => index_name) }
-          when :in      then ->(rql){ rql.get_all(*clause.value, :index => index_name) }
-          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => index_name,
+          when :eq      then ->(rql){ rql.get_all(clause.value, :index => aliased_index) }
+          when :in      then ->(rql){ rql.get_all(*clause.value, :index => aliased_index) }
+          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => aliased_index,
                                                   :left_bound => :closed, :right_bound => :closed) }
         end
       end
@@ -230,9 +274,11 @@ module NoBrainer::Criteria::Where
 
       if index_name
         indexed_clauses = index_values.map { |field| clauses[field] }
+        aliased_index = criteria.klass.indexes[index_name][:as]
         self.index_name = index_name
-        self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - indexed_clauses)
-        self.rql_proc = ->(rql){ rql.get_all(indexed_clauses.map { |c| c.value }, :index => index_name) }
+        self.ast = remove_from_ast(indexed_clauses)
+        self.index_type = :get_all
+        self.rql_proc = ->(rql){ rql.get_all(indexed_clauses.map { |c| c.value }, :index => aliased_index) }
       end
     end
 
@@ -245,40 +291,63 @@ module NoBrainer::Criteria::Where
         left_bound = op_clauses[:gt] || op_clauses[:ge]
         right_bound = op_clauses[:lt] || op_clauses[:le]
 
+        aliased_index = criteria.klass.indexes[index_name][:as]
         self.index_name = index_name
-        self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - [left_bound, right_bound].compact)
+        self.ast = remove_from_ast([left_bound, right_bound].compact)
 
-        options = {:index => index_name}
+        options = {}
+        options[:index] = aliased_index
         options[:left_bound]  = {:gt => :open, :ge => :closed}[left_bound.op] if left_bound
         options[:right_bound] = {:lt => :open, :le => :closed}[right_bound.op] if right_bound
+        self.index_type = :between
         self.rql_proc = ->(rql){ rql.between(left_bound.try(:value), right_bound.try(:value), options) }
       end
     end
 
+    def find_union_index
+      indexes = []
+      index_finder = self
+
+      loop do
+        index_finder = index_finder.dup
+        break unless index_finder.find_index_canonical
+        # TODO To use a compound index, we'd have to add all permutations in the query
+        indexes << index_finder
+        break unless index_finder.ast
+      end
+
+      if indexes.present? && !index_finder.ast
+        self.ast = nil
+        self.index_name = indexes.map(&:index_name)
+        self.index_type = indexes.map(&:index_type)
+        self.rql_proc = ->(rql){ indexes.map { |index| index.rql_proc.call(rql) }.reduce { |a,b| a.union(b) } }
+      end
+    end
+
     def find_index
-      return if criteria.__send__(:without_index?)
-      find_index_canonical || find_index_compound || find_index_hidden_between
-      if criteria.with_index_name && !could_find_index?
-        raise NoBrainer::Error::CannotUseIndex.new("Cannot use index #{criteria.with_index_name}")
+      return if ast.nil? || criteria.without_index?
+      case ast.op
+      when :and then find_index_compound || find_index_canonical || find_index_hidden_between
+      when :or  then find_union_index
       end
     end
   end
 
-  def index_finder
-    return with_default_scope_applied.__send__(:index_finder) if should_apply_default_scope?
-    @index_finder ||= IndexFinder.new(self)
+  def where_index_finder
+    return finalized_criteria.__send__(:where_index_finder) unless finalized?
+    @where_index_finder ||= IndexFinder.new(self, where_ast).tap { |index_finder| index_finder.find_index }
   end
 
   def compile_rql_pass1
     rql = super
-    rql = index_finder.rql_proc.call(rql) if index_finder.could_find_index?
+    rql = where_index_finder.rql_proc.call(rql) if where_index_finder.could_find_index?
     rql
   end
 
   def compile_rql_pass2
     rql = super
-    ast = index_finder.could_find_index? ? index_finder.ast : self.where_ast
-    rql = rql.filter { |doc| ast.to_rql(doc) } if ast.clauses.present?
+    ast = where_index_finder.could_find_index? ? where_index_finder.ast : self.where_ast
+    rql = rql.filter { |doc| ast.to_rql(doc) } if ast.try(:clauses).present?
     rql
   end
 end