nobrainer 0.18.0 → 0.22.0

data/lib/no_brainer/criteria/where.rb

@@ -1,47 +1,48 @@
 module NoBrainer::Criteria::Where
-  extend ActiveSupport::Concern
+  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)
 
-  included { attr_accessor :where_ast, :with_index_name }
+  extend ActiveSupport::Concern
+  include ActiveModel::ForbiddenAttributesProtection
 
-  def initialize(options={})
-    super
+  included do
+    criteria_option :where_ast, :merge_with => NoBrainer::Criteria::Where.method(:merge_where_ast)
+    criteria_option :without_distinct, :merge_with => :set_scalar
   end
 
   def where(*args, &block)
-    chain { |criteria| criteria.where_ast = parse_clause([*args, block].compact) }
+    chain(:where_ast => parse_clause([*args, block].compact))
   end
 
-  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
+  def self.merge_where_ast(a, b)
+    (a ? MultiOperator.new(:and, [a, b]) : b).simplify
   end
 
   def where_present?
-    finalized_criteria.where_ast.try(:clauses).present?
+    finalized_criteria.options[:where_ast].try(:clauses).present?
   end
 
   def where_indexed?
-    !!where_index_name
+    where_index_name.present?
   end
 
   def where_index_name
-    where_index_finder.index_name
+    index = where_index_finder.strategy.try(:index)
+    index.is_a?(Array) ? index.map(&:name) : index.try(:name)
   end
 
   def where_index_type
-    where_index_finder.index_type
+    where_index_finder.strategy.try(:rql_op)
+  end
+
+  def without_distinct(value = true)
+    # helper for delete_all which can't operate on distinct
+    chain(:without_distinct => value)
   end
 
   private
@@ -49,7 +50,7 @@ module NoBrainer::Criteria::Where
   class MultiOperator < Struct.new(:op, :clauses)
     def simplify
       clauses = self.clauses.map(&:simplify)
-      if self.clauses.size == 1 && self.clauses.first.is_a?(self.class)
+      if clauses.size == 1 && clauses.first.is_a?(self.class)
         return clauses.first
       end
 
@@ -57,19 +58,19 @@ module NoBrainer::Criteria::Where
         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 =  BinaryOperator.simplify_clauses(op, simplified_clauses.uniq)
+      simplified_clauses = BinaryOperator.simplify_clauses(op, simplified_clauses.uniq)
       self.class.new(op, simplified_clauses)
     end
 
     def to_rql(doc)
       case op
-      when :and then clauses.map { |c| c.to_rql(doc) }.reduce { |a,b| a & b }
-      when :or  then clauses.map { |c| c.to_rql(doc) }.reduce { |a,b| a | b }
+      when :and then clauses.map { |c| c.to_rql(doc) }.reduce(:&)
+      when :or  then clauses.map { |c| c.to_rql(doc) }.reduce(:|)
       end
     end
   end
 
-  class BinaryOperator < Struct.new(:key, :op, :value, :model, :casted_values)
+  class BinaryOperator < Struct.new(:key, :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
@@ -78,14 +79,14 @@ 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(&:key).map do |key, clauses|
-          case clauses.size
-          when 1 then clauses.first
-          else
+        new_clauses = eq_clauses.group_by { |c| [c.key, c.key_modifier] }.map do |(key, 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, :in, values, clauses.first.model, true)
+            [BinaryOperator.new(key, key_modifier, :in, values, clauses.first.model, true)]
+          else
+            clauses
           end
-        end
+        end.flatten(1)
 
         if new_clauses.size != eq_clauses.size
           ast_clauses = ast_clauses - eq_clauses + new_clauses
@@ -96,29 +97,57 @@ module NoBrainer::Criteria::Where
     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)), 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)), model, true)
-      else BinaryOperator.new(key, op, cast_value(value), model, true)
+      new_key = cast_key(key)
+      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]
+          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)]
       end
+      BinaryOperator.new(new_key, key_modifier, new_op, new_value, model, true)
     end
 
     def to_rql(doc)
       key = model.lookup_field_alias(self.key)
+
+      case key_modifier
+      when :scalar then
+        case op
+        when :defined 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)
+      when :all then doc[key].map { |lvalue| to_rql_scalar(lvalue) }.contains(false).not
+      end
+    end
+
+    def to_rql_scalar(lvalue)
       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)
-      when :in      then RethinkDB::RQL.new.expr(value).contains(doc[key])
-      else doc[key].__send__(op, value)
+      when :between    then (lvalue >= value.min) & (lvalue <= value.max)
+      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
+      else lvalue.__send__(op, value)
       end
     end
 
+    def compatible_with_index?(index)
+      [key_modifier, index.multi].in?([[:any, true], [:scalar, false]])
+    end
+
     private
 
     def association
@@ -135,11 +164,36 @@ module NoBrainer::Criteria::Where
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata
         target_model = association.target_model
-        opts = { :attr_name => key, :value => value, :type => target_model}
-        raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_model)
+        unless value.is_a?(target_model)
+          opts = { :model => model, :attr_name => key, :type => target_model, :value => value }
+          raise NoBrainer::Error::InvalidType.new(opts)
+        end
         value.pk_value
       else
-        model.cast_user_to_db_for(key, value)
+        case op
+        when :defined 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])
+          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
+        end
       end
     end
 
@@ -148,9 +202,14 @@ module NoBrainer::Criteria::Where
 
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata then association.foreign_key
-      else key
+      else ensure_valid_key!(key); key
       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)
@@ -176,11 +235,12 @@ module NoBrainer::Criteria::Where
   end
 
   def parse_clause(clause)
+    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 Proc  then Lambda.new(clause)
-    when NoBrainer::DecoratedSymbol
+    when Symbol::Decoration
       case clause.args.size
       when 1 then parse_clause_stub(clause, clause.args.first)
       else raise "Invalid argument: #{clause}"
@@ -191,154 +251,208 @@ module NoBrainer::Criteria::Where
 
   def parse_clause_stub(key, value)
     case key
-    when :and then MultiOperator.new(:and, value.map { |v| parse_clause(v) })
-    when :or  then MultiOperator.new(:or,  value.map { |v| parse_clause(v) })
-    when :not then UnaryOperator.new(:not, parse_clause(value))
+    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 NoBrainer::DecoratedSymbol then
-      case key.modifier
+    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 :ne  then parse_clause(:not => { key.symbol.eq => 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 BinaryOperator.new(key.symbol, key.modifier, value, self.model)
+      else instantiate_binary_op(key.symbol, key.decorator, value)
       end
     else raise "Invalid key: #{key}"
     end
   end
 
+  def parse_multi_value(op, value, 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]
+      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 BinaryOperator.new(key, :between, value, self.model)
-    when Regexp then BinaryOperator.new(key, :match, value.inspect[1..-2], self.model)
-    else BinaryOperator.new(key, :eq, value, self.model)
+    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
   end
 
-  class IndexFinder < Struct.new(:criteria, :ast, :index_name, :index_type, :rql_proc)
-    def initialize(*args)
-      super
+  def translate_regexp_to_re2_syntax(value)
+    # Ruby always uses what RE2 calls "multiline mode" (the "m" flag),
+    # meaning that "foo\nbar" matches /^bar$/.
+    #
+    # Ruby's /m modifier means that . matches \n and corresponds to RE2's "s" flag.
+
+    flags = "m"
+    flags << "s" if value.options & Regexp::MULTILINE != 0
+    flags << "i" if value.options & Regexp::IGNORECASE != 0
+
+    "(?#{flags})#{value.source}"
+  end
+
+  def instantiate_binary_op(key, op, value)
+    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)
     end
+  end
+
+  class IndexFinder < Struct.new(:criteria, :ast, :strategy)
+    class Strategy < Struct.new(:index_finder, :rql_op, :index, :ast, :rql_proc); end
+    class IndexStrategy < Struct.new(:index_finder, :criteria_ast, :optimized_clauses, :index, :rql_op, :rql_args, :rql_options)
+      def ast
+        MultiOperator.new(criteria_ast.op, criteria_ast.clauses - optimized_clauses)
+      end
 
-    def could_find_index?
-      !!self.index_name
+      def rql_proc
+        lambda do |rql|
+          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
+        end
+      end
     end
 
     def get_candidate_clauses(*types)
       BinaryOperator.get_candidate_clauses(ast.clauses, *types)
     end
 
-    def get_usable_indexes(*types)
-      @usable_indexes = {}
-      @usable_indexes[types] ||= begin
-        indexes = criteria.model.indexes.values
-        indexes = indexes.select { |i| types.include?(i.kind) } if types.present?
-        if criteria.with_index_name && criteria.with_index_name != true
-          indexes = indexes.select { |i| i.name == criteria.with_index_name.to_sym }
-        end
-        indexes
+    def get_usable_indexes(options={})
+      indexes = criteria.model.indexes.values
+      options.each { |k,v| indexes = indexes.select { |i| v == i.__send__(k) } }
+      if criteria.options[:use_index] && criteria.options[:use_index] != true
+        indexes = indexes.select { |i| i.name == criteria.options[:use_index].to_sym }
       end
+      indexes
     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
-      clauses = Hash[get_candidate_clauses(:eq, :in, :between).map { |c| [c.key, c] }]
-      return unless clauses.present?
-
-      if index = get_usable_indexes.select { |i| clauses[i.name] }.first
-        clause = clauses[index.name]
-        self.index_name = index.name
-        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.aliased_name) }
-          when :in      then ->(rql){ rql.get_all(*clause.value, :index => index.aliased_name) }
-          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => index.aliased_name,
-                                                  :left_bound => :closed, :right_bound => :closed) }
+    def find_strategy_canonical
+      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] }]
+      clauses.map do |clause|
+        index = usable_indexes[clause.key]
+        next unless index && clause.compatible_with_index?(index)
+        next unless index.geo == [:near, :intersects].include?(clause.op)
+
+        args = case clause.op
+          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]
+          when :eq      then [:get_all, [clause.value]]
+          when :in      then [:get_all, clause.value]
+          when :between then [:between, [clause.value.min, clause.value.max],
+                              :left_bound => :closed, :right_bound => :closed]
         end
-      end
+        IndexStrategy.new(self, ast, [clause], index, *args)
+      end.compact.sort_by { |strat| usable_indexes.values.index(strat.index) }.first
     end
 
-    def find_index_compound
+    def find_strategy_compound
       clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key, c] }]
-      return unless clauses.present?
+      return nil unless clauses.present?
 
-      if index = get_usable_indexes(:compound).select { |i| i.what & clauses.keys == i.what }.first
+      get_usable_indexes(:kind => :compound, :geo => false, :multi => false).each do |index|
         indexed_clauses = index.what.map { |field| clauses[field] }
-        self.index_name = 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 => index.aliased_name) }
+        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)])
       end
+      return nil
     end
 
-    def find_index_hidden_between
+    def find_strategy_hidden_between
       clauses = get_candidate_clauses(:gt, :ge, :lt, :le).group_by(&:key)
-      return unless clauses.present?
+      return nil unless clauses.present?
 
-      if index = get_usable_indexes.select { |i| clauses[i.name] }.first
-        op_clauses = Hash[clauses[index.name].map { |c| [c.op, c] }]
-        left_bound = op_clauses[:gt] || op_clauses[:ge]
+      get_usable_indexes(:geo => false).each do |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] }]
+        left_bound  = op_clauses[:gt] || op_clauses[:ge]
         right_bound = op_clauses[:lt] || op_clauses[:le]
 
-        self.index_name = index.name
-        self.ast = remove_from_ast([left_bound, right_bound].compact)
+        # XXX we must keep only one bound when using `any', otherwise we get different semantics.
+        right_bound = nil if index.multi && left_bound && right_bound
 
         options = {}
-        options[:index] = index.aliased_name
-        options[:left_bound]  = {:gt => :open, :ge => :closed}[left_bound.op] if left_bound
+        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) }
+
+        return IndexStrategy.new(self, ast, [left_bound, right_bound].compact, index, :between,
+                                 [left_bound.try(:value), right_bound.try(:value)], options)
       end
+      return nil
     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
+    def find_strategy_union
+      strategies = ast.clauses.map do |inner_ast|
+        inner_ast = MultiOperator.new(:and, [inner_ast]) unless inner_ast.is_a?(MultiOperator)
+        raise 'fatal' unless inner_ast.op == :and
+        self.class.new(criteria, inner_ast).find_strategy
       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) } }
+      return nil if strategies.any?(&:nil?)
+
+      rql_proc = lambda do |base_rql|
+        strategies.map do |strategy|
+          rql = strategy.rql_proc.call(base_rql)
+          rql = rql.filter { |doc| strategy.ast.to_rql(doc) } if strategy.ast.try(:clauses).present?
+          rql
+        end.reduce(:union).distinct
       end
+
+      Strategy.new(self, :union, strategies.map(&:index), nil, rql_proc)
     end
 
-    def find_index
-      return if ast.nil? || criteria.without_index?
+    def find_strategy
+      return nil unless ast.try(:clauses).present? && !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
+      when :and then find_strategy_compound || find_strategy_canonical || find_strategy_hidden_between
+      when :or  then find_strategy_union
       end
     end
+
+    def find_strategy!
+      self.strategy = find_strategy
+    end
   end
 
   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 }
+    @where_index_finder ||= IndexFinder.new(self, @options[:where_ast]).tap(&:find_strategy!)
   end
 
   def compile_rql_pass1
     rql = super
-    rql = where_index_finder.rql_proc.call(rql) if where_index_finder.could_find_index?
+    rql = where_index_finder.strategy.rql_proc.call(rql) if where_indexed?
     rql
   end
 
   def compile_rql_pass2
     rql = super
-    ast = where_index_finder.could_find_index? ? where_index_finder.ast : self.where_ast
+    ast = where_indexed? ? where_index_finder.strategy.ast : @options[:where_ast]
     rql = rql.filter { |doc| ast.to_rql(doc) } if ast.try(:clauses).present?
     rql
   end

data/lib/no_brainer/criteria.rb

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

data/lib/no_brainer/document/aliases.rb

@@ -12,9 +12,9 @@ module NoBrainer::Document::Aliases
 
   module ClassMethods
     def _field(attr, options={})
-      if options[:as]
-        self.alias_map[attr.to_s] = options[:as].to_s
-        self.alias_reverse_map[options[:as].to_s] = attr.to_s
+      if options[:store_as]
+        self.alias_map[attr.to_s] = options[:store_as].to_s
+        self.alias_reverse_map[options[:store_as].to_s] = attr.to_s
       end
       super
     end

data/lib/no_brainer/document/association/belongs_to.rb

@@ -2,7 +2,7 @@ class NoBrainer::Document::Association::BelongsTo
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_as, :index, :validates, :required]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_store_as, :index, :validates, :required]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
@@ -21,6 +21,10 @@ class NoBrainer::Document::Association::BelongsTo
       (options[:class_name] || target_name.to_s.camelize).constantize
     end
 
+    def base_criteria
+      target_model.unscoped
+    end
+
     def hook
       super
 
@@ -29,16 +33,16 @@ class NoBrainer::Document::Association::BelongsTo
       # This would have the effect of loading all the models because they
       # are likely to be related to each other. So we don't know the type
       # of the primary key of the target.
-      owner_model.field(foreign_key, :as => options[:foreign_key_as], :index => options[:index])
-      owner_model.validates(target_name, { :presence => true }) if options[:required]
+      owner_model.field(foreign_key, :store_as => options[:foreign_key_store_as], :index => options[:index])
+      owner_model.validates(target_name, :presence => options[:required]) if options[:required]
       owner_model.validates(target_name, options[:validates]) if options[:validates]
 
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
+      delegate("#{target_name}_changed?", "#{foreign_key}_changed?", :to => :self)
       add_callback_for(:after_validation)
     end
 
-    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ primary_key },
-                    :unscoped => true
+    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ primary_key }
   end
 
   # Note:

data/lib/no_brainer/document/association/core.rb

@@ -20,12 +20,13 @@ module NoBrainer::Document::Association::Core
       association_model.new(self, owner)
     end
 
-    def delegate(method_name, target, options={})
+    def delegate(method_src, method_dst, options={})
       metadata = self
       owner_model.inject_in_layer :associations do
-        define_method(method_name) do |*args, &block|
+        define_method(method_src) do |*args, &block|
           super(*args, &block) if options[:call_super]
-          associations[metadata].__send__(target, *args, &block)
+          target = options[:to] == :self ? self : associations[metadata]
+          target.__send__(method_dst, *args, &block)
         end
       end
     end
@@ -37,7 +38,7 @@ module NoBrainer::Document::Association::Core
     end
 
     def add_callback_for(what)
-      instance_eval <<-RUBY, __FILE__, __LINE__+1
+      instance_eval <<-RUBY, __FILE__, __LINE__ + 1
         if !@added_#{what}
           metadata = self
           owner_model.#{what} { associations[metadata].#{what}_callback }
@@ -49,7 +50,7 @@ module NoBrainer::Document::Association::Core
 
   included { attr_accessor :metadata, :owner }
 
-  delegate :primary_key, :foreign_key, :target_name, :target_model, :to => :metadata
+  delegate :primary_key, :foreign_key, :target_name, :target_model, :base_criteria, :to => :metadata
 
   def initialize(metadata, owner)
     @metadata, @owner = metadata, owner