nobrainer 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56337a0aa87999793ca7bc6ed3e1de79ef76b427
-  data.tar.gz: 6740efd7304818a5a71638a639b48301d16eb602
+  metadata.gz: 950e98b70408c2d1fc05a6ee2e80f1f3e942999b
+  data.tar.gz: 5b4ec8da15e3d9f48e1729f07cd336af12c27433
 SHA512:
-  metadata.gz: 69a4a851eb9e3a497a2bff26c65933437e3155b23f6573e1a9d7fcaa04980f59964b7d6f59383e3c7b9bb27014ab95eda52ca8be38d4b4f82144d2c389e211b6
-  data.tar.gz: 03968de9d8391cd208938420fa19d1aa1f2c76191bf938132f5c04dce33f673e725f5336390c010bb70cf3ff660a79a0b7dd72cc27bca994ba6411445f797948
+  metadata.gz: 3719c006243290324956ec397d700cae2766598460423199bfc9ed3f731761b2d6fceec50365f2a839099b2edc3fb751aa88984a349aab4ef2132b6547444f09
+  data.tar.gz: 02bc9ef3d13a887305d6fdd81a7f1eebd296a63c206f9347bce5e8078f3af71c36e625d9ebe5ac0ce55a93da24b5760842ef3e2b6e55738d38df189d6384c731

data/lib/no_brainer/connection.rb

@@ -42,17 +42,23 @@ class NoBrainer::Connection
     RUBY
   end
 
+  def default_db
+    parsed_uri[:db]
+  end
+
+  def current_db
+    NoBrainer.current_run_options.try(:[], :db) || default_db
+  end
+
   def drop!
-    # XXX Thread.current[:nobrainer_options] is set by NoBrainer::QueryRunner::RunOptions
-    db = (Thread.current[:nobrainer_options] || parsed_uri)[:db]
-    db_drop(db)['dropped'] == 1
+    db_drop(current_db)['dropped'] == 1
   end
 
-  # Note that truncating each table (purge) is much faster than dropping the
-  # database (drop)
+  # Note that truncating each table (purge!) is much faster than dropping the database (drop!)
   def purge!
     table_list.each do |table_name|
-      next if table_name == 'nobrainer_index_meta' # keeping because indexes are not going away
+      # keeping the index meta store because indexes are not going away
+      next if table_name == NoBrainer::Document::Index::MetaStore.table_name
       NoBrainer.run { |r| r.table(table_name).delete }
     end
     true

data/lib/no_brainer/criteria/cache.rb

@@ -77,4 +77,12 @@ module NoBrainer::Criteria::Cache
 
   use_cache_for :first, :last, :count, :empty?, :any?
   reload_on :update_all, :destroy_all, :delete_all
+
+  private
+
+  def apply_named_scope(name, args, block)
+    return super unless with_cache?
+    @scope_cache ||= {}
+    @scope_cache[[name, args, block]] ||= super
+  end
 end

data/lib/no_brainer/criteria/core.rb

@@ -56,11 +56,6 @@ module NoBrainer::Criteria::Core
     merge(self.class.new(options), merge_options)
   end
 
-  def run(&block)
-    block ||= proc { to_rql }
-    NoBrainer.run(:criteria => self, &block)
-  end
-
   def compile_rql_pass1
     # This method is overriden by other modules.
     raise "Criteria not bound to a model" unless model
@@ -105,5 +100,9 @@ module NoBrainer::Criteria::Core
     def append_array(a, b)
       a ? a+b : b
     end
+
+    def merge_hash(a, b)
+      a ? a.merge(b) : b
+    end
   end
 end

data/lib/no_brainer/criteria/eager_load.rb

@@ -15,7 +15,7 @@ module NoBrainer::Criteria::EagerLoad
   def merge!(criteria, options={})
     super.tap do
       # If we already have some cached documents, and we need to so some eager
-      # loading, then we it now. It's easier than doing it lazily.
+      # loading, then we do it now. It's easier than doing it lazily.
       if self.cached? && criteria.options[:eager_load].present?
         perform_eager_load(@cache)
       end

data/lib/no_brainer/criteria/find.rb

@@ -1,27 +1,24 @@
 module NoBrainer::Criteria::Find
   extend ActiveSupport::Concern
 
-  def find_by?(*args, &block)
-    where(*args, &block).first
-  end
-
   def find_by(*args, &block)
-    find_by?(*args, &block).tap { |doc| raise_not_found(args) unless doc }
+    raise "find_by() has unclear semantics. Please use where().first instead"
   end
   alias_method :find_by!, :find_by
+  alias_method :find_by?, :find_by
 
   def find?(pk)
-    without_ordering.find_by?(model.pk_name => pk)
+    without_ordering.where(model.pk_name => pk).first
   end
 
   def find(pk)
-    without_ordering.find_by(model.pk_name => pk)
+    find?(pk).tap { |doc| raise_not_found(pk) unless doc }
   end
   alias_method :find!, :find
 
   private
 
-  def raise_not_found(args)
-    raise NoBrainer::Error::DocumentNotFound, "#{model} #{args.inspect.gsub(/\[{(.*)}\]/, '\1')} not found"
+  def raise_not_found(pk)
+    raise NoBrainer::Error::DocumentNotFound, "#{model} :#{model.pk_name}=>#{pk.inspect} not found"
   end
 end

data/lib/no_brainer/criteria/first_or_create.rb

@@ -0,0 +1,101 @@
+module NoBrainer::Criteria::FirstOrCreate
+  extend ActiveSupport::Concern
+
+  def first_or_create(create_params={}, &block)
+    _first_or_create(create_params, :save_method => :save?, &block)
+  end
+
+  def first_or_create!(create_params={}, &block)
+    _first_or_create(create_params, :save_method => :save!, &block)
+  end
+
+  private
+
+  def _first_or_create(create_params={}, options={}, &block)
+    raise "Cannot use .raw() with .first_or_create()" if raw?
+    raise "Use first_or_create() on the root class `#{model.root_class}'" unless model.is_root_class?
+
+    where_params = extract_where_params()
+    keys = where_params.keys
+
+    # When matching on the primary key, we'll just pretend that we have a
+    # uniqueness validator on it. We will be racy against other create(),
+    # but not on first_or_create().
+    # And if we get caught in a race with another create(), we'll just have a
+    # duplicate primary key exception.
+    matched_validator = true if keys == [model.pk_name]
+    matched_validator ||= !!get_uniqueness_validators_map[keys.sort]
+    unless matched_validator
+      # We could do without a uniqueness validator, but it's much preferable to
+      # have it, so that we don't conflict with others create(), not just others
+      # first_or_create().
+      raise "Please add the following uniqueness validator for first_or_create():\n" +
+        "class #{model}\n" +
+          case keys.size
+          when 1 then "  field :#{keys.first}, :uniq => true"
+          when 2 then "  field :#{keys.first}, :uniq => {:scope => :#{keys.last}}"
+          else        "  field :#{keys.first}, :uniq => {:scope => #{keys[1..-1].inspect}}"
+          end +
+        "\nend"
+    end
+
+    # We don't want to access create_params yet, because invoking the block
+    # might be costly (the user might be doing some API call or w/e), and
+    # so we want to invoke the block only if necessary.
+    new_instance = model.new(where_params)
+    lock_key_name = model._uniqueness_key_name_from_params(where_params)
+    new_instance._lock_for_uniqueness_once(lock_key_name)
+
+    old_instance = self.first
+    return old_instance if old_instance
+
+    create_params = block.call if block
+    create_params = create_params.symbolize_keys
+
+    keys_in_conflict = create_params.keys & where_params.keys
+    keys_in_conflict = keys_in_conflict.select { |k| create_params[k] == where_params[k] }
+    unless keys_in_conflict.empty?
+      raise "where() and first_or_create() were given conflicting values " +
+            "on the following keys: #{keys_in_conflict.inspect}"
+    end
+
+    if create_params[:_type]
+      # We have to recreate the instance because we are given a _type in
+      # create_params specifying a subclass. We'll have to transfert the lock
+      # ownership to that new instance.
+      new_instance = model.model_from_attrs(create_params).new(where_params).tap do |i|
+        i.locked_keys_for_uniqueness = new_instance.locked_keys_for_uniqueness
+      end
+    end
+
+    new_instance.assign_attributes(create_params)
+    new_instance.__send__(options[:save_method])
+    return new_instance
+  ensure
+    new_instance.try(:unlock_unique_fields)
+  end
+
+  def extract_where_params()
+    where_clauses = finalized_criteria.options[:where_ast]
+
+    unless where_clauses.is_a?(NoBrainer::Criteria::Where::MultiOperator) &&
+           where_clauses.op == :and && where_clauses.clauses.size > 0 &&
+           where_clauses.clauses.all? do |c|
+             c.is_a?(NoBrainer::Criteria::Where::BinaryOperator) &&
+             c.op == :eq && c.key_modifier == :scalar
+           end
+      raise "Please use a query of the form `.where(...).first_or_create(...)'"
+    end
+
+    Hash[where_clauses.clauses.map do |c|
+      raise "You may not use nested hash queries with first_or.create()" if c.key_path.size > 1
+      [c.key_path.first.to_sym, c.value]
+    end]
+  end
+
+  def get_uniqueness_validators_map
+    Hash[model.unique_validators
+     .flat_map { |validator| validator.attributes.map { |attr| [attr, validator] } }
+     .map { |f, validator| [[f, *validator.scope].map(&:to_sym).sort, validator] }]
+  end
+end

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

@@ -57,7 +57,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 +70,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 +79,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,7 +97,7 @@ module NoBrainer::Criteria::Where
     end
 
     def simplify
-      new_key = cast_key(key)
+      new_key_path = cast_key_path(key_path)
       new_op, new_value = case op
         when :in then
           case value
@@ -111,11 +111,14 @@ module NoBrainer::Criteria::Where
           [op, cast_value(value)]
         else [op, cast_value(value)]
       end
-      BinaryOperator.new(new_key, key_modifier, new_op, new_value, model, true)
+      BinaryOperator.new(new_key_path, 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
@@ -148,10 +151,8 @@ module NoBrainer::Criteria::Where
     private
 
     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
 
@@ -162,7 +163,7 @@ 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
@@ -173,38 +174,43 @@ module NoBrainer::Criteria::Where
           raise "Use a geo object with `intersects`" unless value.is_a?(NoBrainer::Geo::Base)
           value
         when :near
+          # 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] }
+          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
-            when NoBrainer::Geo::Circle then { :circle => value }
-            else raise "Incorrect use of `near': rvalue must be a hash or a circle"
+              { :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
         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 model.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
   end
@@ -240,49 +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 instantiate_binary_op(key, :eq, 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, :not then instantiate_binary_op(key, :eq, value)
-      when :gte then instantiate_binary_op(key.symbol, :ge, value)
-      when :lte then instantiate_binary_op(key.symbol, :le, 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) })
+    MultiOperator.new(op, value.map { |v| parse_clause(v, options) })
   end
 
   def translate_regexp_to_re2_syntax(value)
@@ -298,21 +308,22 @@ 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] || []
     case key
     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(key.symbol, key.decorator, op, value, self.model)
-        when :not       then UnaryOperator.new(:not, BinaryOperator.new(key.symbol, :scalar, op, value, self.model))
+        when :any, :all then BinaryOperator.new(nested_prefix + [key.symbol], key.decorator, op, value, self.model)
+        when :not       then UnaryOperator.new(:not, BinaryOperator.new(nested_prefix + [key.symbol], :scalar, op, value, self.model))
       end
-    else BinaryOperator.new(key, :scalar, op, value, self.model)
+    else BinaryOperator.new(nested_prefix + [key], :scalar, op, value, self.model)
     end
   end
 
@@ -353,9 +364,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)
 
@@ -377,11 +388,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)])
@@ -390,11 +401,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] }]

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, :Aggregate, :EagerLoad, :Update,
+                       :Cache, :Index, :Extend
 end

data/lib/no_brainer/document/criteria.rb

@@ -17,7 +17,7 @@ module NoBrainer::Document::Criteria
              :raw,                           # Raw
              :limit, :offset, :skip,         # Limit
              :order_by, :reverse_order, :without_ordering, :order_by_indexed?, :order_by_index_name, # OrderBy
-             :scoped, :unscoped,             # Scope
+             :unscoped,                      # Scope
              :where, :where_indexed?, :where_index_name, :where_index_type, # Where
              :with_index, :without_index, :used_index, # Index
              :with_cache, :without_cache,    # Cache
@@ -26,6 +26,7 @@ module NoBrainer::Document::Criteria
              :preload, :eager_load,          # EagerLoad
              :each, :to_a,                   # Enumerable
              :first, :last, :first!, :last!, :sample, # First
+             :first_or_create, :first_or_create!, # FirstOrCreate
              :min, :max, :sum, :avg,         # Aggregate
              :update_all, :replace_all,      # Update
              :pluck, :without, :lazy_fetch, :without_plucking, # Pluck
@@ -33,7 +34,8 @@ module NoBrainer::Document::Criteria
              :to => :all
 
     def all
-      NoBrainer::Criteria.new(:model => self)
+      NoBrainer::Criteria.new(:initial_run_options => NoBrainer.current_run_options,
+                              :model => self)
     end
 
     def scope(name, criteria=nil, &block)

data/lib/no_brainer/document/index/index.rb

@@ -59,10 +59,8 @@ class NoBrainer::Document::Index::Index < Struct.new(
     NoBrainer::RQL.reset_lambda_var_counter
     NoBrainer.run(model.rql_table.index_create(aliased_name, opt, &rql_proc))
 
-    MetaStore.on(model.database_name) do
-      MetaStore.create(:table_name => model.table_name, :index_name => aliased_name,
-                       :rql_function => serialized_rql_proc)
-    end
+    MetaStore.create(:table_name => model.table_name, :index_name => aliased_name,
+                     :rql_function => serialized_rql_proc)
   end
 
   def delete(options={})
@@ -70,9 +68,7 @@ class NoBrainer::Document::Index::Index < Struct.new(
 
     NoBrainer.run(model.rql_table.index_drop(aliased_name))
 
-    MetaStore.on(model.database_name) do
-      MetaStore.where(:table_name => model.table_name, :index_name => aliased_name).delete_all
-    end
+    MetaStore.where(:table_name => model.table_name, :index_name => aliased_name).delete_all
   end
 
   def update(wanted_index, options={})

data/lib/no_brainer/document/index/meta_store.rb

@@ -6,8 +6,7 @@ class NoBrainer::Document::Index::MetaStore
 
   default_scope ->{ order_by(:created_at) }
 
-  store_in :database => ->{ Thread.current[:nobrainer_meta_store_db] },
-           :table    => 'nobrainer_index_meta'
+  store_in :table => 'nobrainer_index_meta'
 
   field :table_name,   :type => String, :required => true
   field :index_name,   :type => String, :required => true
@@ -20,12 +19,4 @@ class NoBrainer::Document::Index::MetaStore
   def rql_function
     JSON.load(super)
   end
-
-  def self.on(db_name, &block)
-    old_db_name = Thread.current[:nobrainer_meta_store_db]
-    Thread.current[:nobrainer_meta_store_db] = db_name
-    block.call
-  ensure
-    Thread.current[:nobrainer_meta_store_db] = old_db_name
-  end
 end

data/lib/no_brainer/document/index/synchronizer.rb

@@ -8,9 +8,8 @@ class NoBrainer::Document::Index::Synchronizer
     end]
   end
 
-  def meta_store_on(db_name)
-    @meta_store ||= {}
-    @meta_store[db_name] ||= MetaStore.on(db_name) { MetaStore.all.to_a }
+  def meta_store
+    @meta_store ||= MetaStore.to_a
   end
 
   class Op < Struct.new(:index, :op, :args)
@@ -21,8 +20,7 @@ class NoBrainer::Document::Index::Synchronizer
 
   def _generate_plan_for(model, wanted_indexes)
     current_indexes = NoBrainer.run(model.rql_table.index_status).map do |s|
-      meta = meta_store_on(model.database_name)
-               .select { |i| i.table_name == model.table_name && i.index_name == s['index'] }.last
+      meta = meta_store.select { |i| i.table_name == model.table_name && i.index_name == s['index'] }.last
       Index.new(model, s['index'], s['index'], nil, nil, nil, s['geo'], s['multi'], meta)
     end
 
@@ -46,7 +44,7 @@ class NoBrainer::Document::Index::Synchronizer
   end
 
   def generate_plan
-    @models_indexes_map.map { |model, indexes| _generate_plan_for(model, indexes) }.flatten(1)
+    @models_indexes_map.flat_map { |model, indexes| _generate_plan_for(model, indexes) }
   end
 
   def sync_indexes(options={})

data/lib/no_brainer/document/polymorphic.rb

@@ -37,7 +37,11 @@ module NoBrainer::Document::Polymorphic
     end
 
     def model_from_attrs(attrs)
-      attrs['_type'].try(:constantize) || root_class
+      class_name = attrs['_type'] || attrs[:_type]
+      return root_class unless class_name
+      class_name.to_s.constantize.tap { |cls| raise NameError unless cls <= self }
+    rescue NameError
+      raise NoBrainer::Error::InvalidPolymorphicType, "Invalid polymorphic class: `#{class_name}' is not a `#{self}'"
     end
 
     def all

data/lib/no_brainer/document/store_in.rb

@@ -11,12 +11,13 @@ module NoBrainer::Document::StoreIn
   module ClassMethods
     def store_in(options)
       raise "store_in() must be called on the parent class" unless is_root_class?
-      self.store_in_options.merge!(options)
-    end
 
-    def database_name
-      db = self.store_in_options[:database]
-      (db.is_a?(Proc) ? db.call : db).try(:to_s)
+      if options[:database] || options[:db]
+        STDERR.puts "[NoBrainer] `store_in(db: ...)' has been removed. Use `run_with(db: ...)' instead. Sorry."
+      end
+
+      options.assert_valid_keys(:table)
+      self.store_in_options.merge!(options)
     end
 
     def table_name
@@ -26,10 +27,7 @@ module NoBrainer::Document::StoreIn
     end
 
     def rql_table
-      db = self.database_name
-      rql = RethinkDB::RQL.new
-      rql = rql.db(db) if db
-      rql.table(table_name)
+      RethinkDB::RQL.new.table(table_name)
     end
   end
 end

data/lib/no_brainer/document/validation/uniqueness.rb

@@ -8,41 +8,38 @@ module NoBrainer::Document::Validation::Uniqueness
     unlock_unique_fields
   end
 
-  def _lock_key_from_field(field)
-    value = read_attribute(field).to_s
-    ['nobrainer', self.class.database_name || NoBrainer.connection.parsed_uri[:db],
-     self.class.table_name, field, value.empty? ? 'nil' : value].join(':')
+  def _lock_for_uniqueness_once(key)
+    @locked_keys_for_uniqueness ||= {}
+    @locked_keys_for_uniqueness[key] ||= NoBrainer::Config.distributed_lock_class.new(key).tap(&:lock)
   end
 
-  def lock_unique_fields
-    return unless NoBrainer::Config.distributed_lock_class && !self.class.unique_validators.empty?
+  def unlock_unique_fields
+    @locked_keys_for_uniqueness.to_h.values.each(&:unlock)
+    @locked_keys_for_uniqueness = {}
+  end
 
+  def lock_unique_fields
     self.class.unique_validators
-      .map { |validator| validator.attributes.map { |attr| [attr, validator] } }
-      .flatten(1)
+      .flat_map { |validator| validator.attributes.map { |attr| [attr, validator] } }
       .select { |f, validator| validator.should_validate_field?(self, f) }
-      .map { |f, options| _lock_key_from_field(f) }
-      .sort
-      .uniq
-      .each do |key|
-        lock = NoBrainer::Config.distributed_lock_class.new(key)
-        lock.lock
-        @locked_unique_fields ||= []
-        @locked_unique_fields << lock
-      end
-  end
-
-  def unlock_unique_fields
-    return unless @locked_unique_fields
-    @locked_unique_fields.pop.unlock until @locked_unique_fields.empty?
+      .map { |f, validator| [f, *validator.scope].map { |k| [k, read_attribute(k)] } }
+      .map { |params| self.class._uniqueness_key_name_from_params(params) }
+      .sort.each { |key| _lock_for_uniqueness_once(key) }
   end
 
   included do
     singleton_class.send(:attr_accessor, :unique_validators)
     self.unique_validators = []
+    attr_accessor :locked_keys_for_uniqueness
   end
 
   module ClassMethods
+    def _uniqueness_key_name_from_params(params)
+      ['uniq', NoBrainer.current_db, self.table_name,
+       *params.map { |k,v| [k.to_s, (v = v.to_s; v.empty? ? 'nil' : v)] }.sort
+      ].join(':')
+    end
+
     def validates_uniqueness_of(*attr_names)
       validates_with(UniquenessValidator, _merge_attributes(attr_names))
     end
@@ -54,14 +51,14 @@ module NoBrainer::Document::Validation::Uniqueness
   end
 
   class UniquenessValidator < ActiveModel::EachValidator
-    attr_accessor :scope
+    attr_accessor :scope, :model
 
     def initialize(options={})
       super
-      model = options[:class]
-      self.scope = [*options[:scope]]
-      ([model] + model.descendants).each do |_model|
-        _model.unique_validators << self
+      self.model = options[:class]
+      self.scope = [*options[:scope]].map(&:to_sym)
+      ([model] + model.descendants).each do |subclass|
+        subclass.unique_validators << self
       end
     end
 
@@ -70,7 +67,7 @@ module NoBrainer::Document::Validation::Uniqueness
     end
 
     def validate_each(doc, attr, value)
-      criteria = doc.root_class.unscoped.where(attr => value)
+      criteria = self.model.unscoped.where(attr => value)
       criteria = apply_scopes(criteria, doc)
       criteria = exclude_doc(criteria, doc) if doc.persisted?
       doc.errors.add(attr, :taken, options.except(:scope).merge(:value => value)) unless criteria.empty?

data/lib/no_brainer/error.rb

@@ -12,6 +12,7 @@ module NoBrainer::Error
   class AtomicBlock             < RuntimeError; end
   class LostLock                < RuntimeError; end
   class LockUnavailable         < RuntimeError; end
+  class InvalidPolymorphicType  < RuntimeError; end
 
   class DocumentInvalid < RuntimeError
     attr_accessor :instance

data/lib/no_brainer/lock.rb

@@ -30,12 +30,16 @@ class NoBrainer::Lock
     super(options.merge(:key => key))
   end
 
-  def lock(options={}, &block)
-    if block
-      lock(options)
-      return block.call.tap { unlock }
+  def synchronize(options={}, &block)
+    lock(options)
+    begin
+      block.call
+    ensure
+      unlock
     end
+  end
 
+  def lock(options={})
     options.assert_valid_keys(:expire, :timeout)
     timeout = NoBrainer::Config.lock_options.merge(options)[:timeout]
     sleep_amount = 0.1

data/lib/no_brainer/profiler/logger.rb

@@ -13,9 +13,8 @@ class NoBrainer::Profiler::Logger
     msg_duration = "[#{msg_duration}ms] "
 
     env[:query_type] = NoBrainer::RQL.type_of(env[:query])
-    env[:custom_db_name] = env[:db_name] if env[:db_name].to_s != NoBrainer.connection.parsed_uri[:db]
 
-    msg_db = "[#{env[:custom_db_name]}] " if env[:custom_db_name]
+    msg_db = "[#{env[:options][:db]}] " if env[:options][:db]
     msg_query = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
 
     msg_exception = "#{env[:exception].class} #{env[:exception].message.split("\n").first}" if env[:exception]

data/lib/no_brainer/query_runner/database_on_demand.rb

@@ -2,8 +2,8 @@ class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middlew
   def call(env)
     @runner.call(env)
   rescue RuntimeError => e
-    if database_name = handle_database_on_demand_exception?(env, e)
-      auto_create_database(env, database_name)
+    if db_name = handle_database_on_demand_exception?(env, e)
+      auto_create_database(env, db_name)
       retry
     end
     raise
@@ -15,15 +15,15 @@ class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middlew
 
   private
 
-  def auto_create_database(env, database_name)
-    if env[:last_auto_create_database] == database_name
-      raise "Auto database creation is not working with #{database_name}"
+  def auto_create_database(env, db_name)
+    if env[:last_auto_create_database] == db_name
+      raise "Auto database creation is not working with #{db_name}"
     end
-    env[:last_auto_create_database] = database_name
+    env[:last_auto_create_database] = db_name
 
-    NoBrainer.db_create(database_name)
+    NoBrainer.db_create(db_name)
   rescue RuntimeError => e
     # We might have raced with another db_create
-    raise unless e.message =~ /Database `#{database_name}` already exists/
+    raise unless e.message =~ /Database `#{db_name}` already exists/
   end
 end

data/lib/no_brainer/query_runner/driver.rb

@@ -1,5 +1,7 @@
 class NoBrainer::QueryRunner::Driver < NoBrainer::QueryRunner::Middleware
   def call(env)
-    env[:query].run(NoBrainer.connection.raw, env[:options])
+    options = env[:options]
+    options = options.merge(:db => RethinkDB::RQL.new.db(options[:db])) if options[:db]
+    env[:query].run(NoBrainer.connection.raw, options)
   end
 end

data/lib/no_brainer/query_runner/missing_index.rb

@@ -4,7 +4,7 @@ class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
   rescue RethinkDB::RqlRuntimeError => e
     if e.message =~ /^Index `(.+)` was not found on table `(.+)\.(.+)`\.$/
       index_name = $1
-      database_name = $2
+      db_name = $2
       table_name = $3
 
       model = NoBrainer::Document.all.select { |m| m.table_name == table_name }.first
@@ -12,10 +12,10 @@ class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
       index_name = index.name if index
 
       if model.try(:pk_name).try(:to_s) == index_name.to_s
-        err_msg  = "Please update the primary key `#{index_name}` in the table `#{database_name}.#{table_name}`."
+        err_msg  = "Please update the primary key `#{index_name}` in the table `#{db_name}.#{table_name}`."
       else
         err_msg  = "Please run `NoBrainer.sync_indexes' or `rake nobrainer:sync_indexes' to create the index `#{index_name}`"
-        err_msg += " in the table `#{database_name}.#{table_name}`."
+        err_msg += " in the table `#{db_name}.#{table_name}`."
         err_msg += " Read http://nobrainer.io/docs/indexes for more information."
       end
 

data/lib/no_brainer/query_runner/profiler.rb

@@ -22,7 +22,6 @@ class NoBrainer::QueryRunner::Profiler < NoBrainer::QueryRunner::Middleware
 
     env[:model] = env[:criteria] && env[:criteria].model
     env[:query_type] = NoBrainer::RQL.type_of(env[:query])
-    env[:custom_db_name] = env[:db_name] if env[:db_name] && env[:db_name].to_s != NoBrainer.connection.parsed_uri[:db]
 
     NoBrainer::Profiler.registered_profilers.each do |profiler|
       begin

data/lib/no_brainer/query_runner/run_options.rb

@@ -1,35 +1,55 @@
 class NoBrainer::QueryRunner::RunOptions < NoBrainer::QueryRunner::Middleware
-  # XXX NoBrainer::Database#drop() uses Thread.current[:nobrainer_options]
-
   def self.with_database(db_name, &block)
+    STDERR.puts "[NoBrainer] `with_database()' is deprecated, please use `with(db: ...)' instead"
     with(:db => db_name, &block)
   end
 
   def self.with(options={}, &block)
-    old_options = Thread.current[:nobrainer_options]
-    Thread.current[:nobrainer_options] = (old_options || {}).merge(options.symbolize_keys)
-    block.call if block
+    STDERR.puts "[NoBrainer] `with(...)' is deprecated, please use `run_with(...)' instead"
+    run_with(options, &block)
+  end
+
+  def self.current_run_options
+    Thread.current[:nobrainer_run_with] || {}
+  end
+
+  def self.run_with(options={}, &block)
+    options = options.symbolize_keys
+
+    if options[:database]
+      STDERR.puts "[NoBrainer] `run_with(database: ...)' is deprecated, please use `run_with(db: ...)' instead"
+      options[:db] = options.delete(:database)
+    end
+
+    old_options = Thread.current[:nobrainer_run_with]
+    Thread.current[:nobrainer_run_with] = (old_options || {}).merge(options)
+    block.call
   ensure
-    Thread.current[:nobrainer_options] = old_options
+    Thread.current[:nobrainer_run_with] = old_options
   end
 
   def call(env)
-    env[:options].symbolize_keys!
-    if Thread.current[:nobrainer_options]
-      env[:options].reverse_merge!(Thread.current[:nobrainer_options])
-    end
+    options = env[:options].symbolize_keys
+    options = self.class.current_run_options.merge(options)
 
     if NoBrainer::Config.durability.to_s != 'hard'
-      env[:options].reverse_merge!(:durability => NoBrainer::Config.durability)
+      options[:durability] ||= NoBrainer::Config.durability
     end
 
-    if env[:options][:db] && !env[:options][:db].is_a?(RethinkDB::RQL)
-      env[:db_name] = env[:options][:db].to_s
-      env[:options][:db] = RethinkDB::RQL.new.db(env[:db_name])
+    options[:db] = options[:db].to_s if options[:db]
+    if options[:db].blank? || options[:db] == NoBrainer.default_db
+      options.delete(:db)
     end
 
-    env[:criteria] = env[:options].delete(:criteria)
+    env[:criteria] = options.delete(:criteria)
+
+    if options[:profile] && env[:criteria].try(:raw?) == false
+      STDERR.puts "[NoBrainer]"
+      STDERR.puts "[NoBrainer]\e[1;31m Please use `.raw' in your criteria when profiling\e[0m"
+      STDERR.puts "[NoBrainer]"
+    end
 
+    env[:options] = options
     @runner.call(env)
   end
 end

data/lib/no_brainer/query_runner/table_on_demand.rb

@@ -15,24 +15,24 @@ class NoBrainer::QueryRunner::TableOnDemand < NoBrainer::QueryRunner::Middleware
 
   private
 
-  def auto_create_table(env, database_name, table_name)
+  def auto_create_table(env, db_name, table_name)
     model ||= NoBrainer::Document::Core._all.select { |m| m.table_name == table_name }.first
     model ||= NoBrainer::Document::Core._all_nobrainer.select { |m| m.table_name == table_name }.first
 
     if model.nil?
-      raise "Auto table creation is not working for `#{database_name}.#{table_name}` -- Can't find the corresponding model."
+      raise "Auto table creation is not working for `#{db_name}.#{table_name}` -- Can't find the corresponding model."
     end
 
-    if env[:last_auto_create_table] == [database_name, table_name]
-      raise "Auto table creation is not working for `#{database_name}.#{table_name}`"
+    if env[:last_auto_create_table] == [db_name, table_name]
+      raise "Auto table creation is not working for `#{db_name}.#{table_name}`"
     end
-    env[:last_auto_create_table] = [database_name, table_name]
+    env[:last_auto_create_table] = [db_name, table_name]
 
-    NoBrainer.with_database(database_name) do
+    NoBrainer.run_with(:db => db_name) do
       NoBrainer.table_create(table_name, :primary_key => model.lookup_field_alias(model.pk_name))
     end
   rescue RuntimeError => e
     # We might have raced with another table create
-    raise unless e.message =~ /Table `#{database_name}\.#{table_name}` already exists/
+    raise unless e.message =~ /Table `#{db_name}\.#{table_name}` already exists/
   end
 end

data/lib/nobrainer.rb

@@ -23,12 +23,14 @@ module NoBrainer
 
     delegate :db_create, :db_drop, :db_list,
              :table_create, :table_drop, :table_list,
-             :drop!, :purge!, :to => :connection
+             :drop!, :purge!, :default_db, :current_db, :to => :connection
 
-    delegate :configure, :logger,   :to => 'NoBrainer::Config'
-    delegate :run,                  :to => 'NoBrainer::QueryRunner'
-    delegate :sync_indexes,         :to => 'NoBrainer::Document::Index::Synchronizer'
-    delegate :with, :with_database, :to => 'NoBrainer::QueryRunner::RunOptions'
+    delegate :configure, :logger,             :to => 'NoBrainer::Config'
+    delegate :run,                            :to => 'NoBrainer::QueryRunner'
+    delegate :sync_indexes,                   :to => 'NoBrainer::Document::Index::Synchronizer'
+    delegate :current_run_options, :run_with, :to => 'NoBrainer::QueryRunner::RunOptions'
+
+    delegate :with, :with_database, :to => 'NoBrainer::QueryRunner::RunOptions' # deprecated
 
     def jruby?
       RUBY_PLATFORM == 'java'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.25.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-20 00:00:00.000000000 Z
+date: 2015-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -105,11 +105,13 @@ files:
 - lib/no_brainer/criteria/extend.rb
 - lib/no_brainer/criteria/find.rb
 - lib/no_brainer/criteria/first.rb
+- lib/no_brainer/criteria/first_or_create.rb
 - lib/no_brainer/criteria/index.rb
 - lib/no_brainer/criteria/limit.rb
 - lib/no_brainer/criteria/order_by.rb
 - lib/no_brainer/criteria/pluck.rb
 - lib/no_brainer/criteria/raw.rb
+- lib/no_brainer/criteria/run.rb
 - lib/no_brainer/criteria/scope.rb
 - lib/no_brainer/criteria/update.rb
 - lib/no_brainer/criteria/where.rb
@@ -172,7 +174,6 @@ files:
 - lib/no_brainer/loader.rb
 - lib/no_brainer/locale/en.yml
 - lib/no_brainer/lock.rb
-- lib/no_brainer/logger.rb
 - lib/no_brainer/profiler.rb
 - lib/no_brainer/profiler/controller_runtime.rb
 - lib/no_brainer/profiler/logger.rb

data/lib/no_brainer/logger.rb

@@ -1,46 +0,0 @@
-class NoBrainer::Logger
-  def on_query(env)
-    # env[:end_time] = Time.now
-    # env[:duration] = env[:end_time] - env[:start_time]
-    # env[:exception] = exception
-    # env[:query_type] = NoBrainer::RQL.type_of(env[:query])
-
-    not_indexed = env[:criteria] && env[:criteria].where_present? &&
-                    !env[:criteria].where_indexed? &&
-                    !env[:criteria].model.try(:perf_warnings_disabled)
-
-    level = exception ? Logger::ERROR :
-             not_indexed ? Logger::INFO : Logger::DEBUG
-    return if NoBrainer.logger.nil? || NoBrainer.logger.level > level
-
-    msg_duration = (duration * 1000.0).round(1).to_s
-    msg_duration = " " * [0, 6 - msg_duration.size].max + msg_duration
-    msg_duration = "[#{msg_duration}ms] "
-
-    msg_db = "[#{env[:db_name]}] " if env[:db_name] && env[:db_name].to_s != NoBrainer.connection.parsed_uri[:db]
-    msg_query = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
-
-    msg_exception = "#{exception.class} #{exception.message.split("\n").first}" if exception
-    msg_exception ||= "perf: filtering without using an index" if not_indexed
-
-    msg_last = nil
-
-    if NoBrainer::Config.colorize_logger
-      query_color = case NoBrainer::RQL.type_of(env[:query])
-                    when :write      then "\e[1;31m" # red
-                    when :read       then "\e[1;32m" # green
-                    when :management then "\e[1;33m" # yellow
-                    end
-      msg_duration = [query_color, msg_duration].join
-      msg_db = ["\e[0;34m", msg_db, query_color].join if msg_db
-      if msg_exception
-        exception_color = "\e[0;31m" if level == Logger::ERROR
-        msg_exception = ["\e[0;39m", " -- ", exception_color, msg_exception].compact.join
-      end
-      msg_last = "\e[0m"
-    end
-
-    msg = [msg_duration, msg_db, msg_query, msg_exception, msg_last].join
-    NoBrainer.logger.add(level, msg)
-  end
-end