datastax_rails 1.0.5

data/lib/datastax_rails/relation/modification_methods.rb

@@ -0,0 +1,80 @@
+module DatastaxRails
+  module ModificationMethods
+    # Destroys the records matching +conditions+ by instantiating each
+    # record and calling its +destroy+ method. Each object's callbacks are
+    # executed (including <tt>:dependent</tt> association options and
+    # +before_destroy+/+after_destroy+ Observer methods). Returns the
+    # collection of objects that were destroyed; each will be frozen, to
+    # reflect that no changes should be made (since they can't be
+    # persisted).
+    #
+    # Note: Instantiation, callback execution, and deletion of each
+    # record can be time consuming when you're removing many records at
+    # once. However, it is necessary to perform it this way to ensure
+    # that the SOLR index stays in sync with the Cassandra data store.
+    #
+    # +delete_all+ is aliased to this because you can't delete without running
+    # the requisite callbacks. (at least not yet)
+    #
+    # ==== Parameters
+    #
+    # * +conditions+ - A string, array, or hash that specifies which records
+    # to destroy. If omitted, all records matching the current relation are
+    # destroyed. See the Conditions section in the introduction to
+    # DatastaxRails::Base for more information.
+    #
+    # ==== Examples
+    #
+    # Person.destroy_all(:status => "inactive")
+    # Person.where(:age => 0..18).destroy_all
+    # Person.where_not(:status => "active").destroy_all
+    def destroy_all(conditions = nil)
+      if conditions
+        ret = where(conditions).destroy_all
+      else
+        ret = to_a.each {|object| object.destroy }
+      end
+      reset
+      ret
+    end
+    # TODO: Find a way to delete from both without instantiating
+    alias :delete_all :destroy_all
+    
+    # Destroy an object (or multiple objects) that has the given id, the object is instantiated first,
+    # therefore all callbacks and filters are fired off before the object is deleted. This method is
+    # in-efficient since it actually has to instantiate the object just to delte it but allows cleanup
+    # methods such as the ones that remove the object from SOLR to be run.
+    #
+    # This essentially finds the object (or multiple objects) with the given id, creates a new object
+    # from the attributes, and then calls destroy on it.
+    #
+    # Note: this will only find objects that are matched by the current relation even if the ID would
+    # otherwise be valid.
+    #
+    # +delete+ is aliased to this because you can't delete without running
+    # the requisite callbacks. (at least not yet)
+    #
+    # ==== Parameters
+    #
+    # * +id+ - Can be either an Integer or an Array of Integers.
+    #
+    # ==== Examples
+    #
+    # # Destroy a single object
+    # Todo.destroy(1)
+    #
+    # # Destroy multiple objects
+    # todos = [1,2,3]
+    # Todo.destroy(todos)
+    def destroy(id)
+      if id.is_a?(Array)
+        ret = id.map { |one_id| destroy(one_id) }
+      else
+        ret = find(id).destroy
+      end
+      reset
+      ret
+    end
+    alias :delete :destroy
+  end
+end

data/lib/datastax_rails/relation/search_methods.rb

@@ -0,0 +1,349 @@
+module DatastaxRails
+  module SearchMethods
+    
+    # Normally special characters (other than wild cards) are escaped before the search
+    # is submitted.  If you want to handle escaping yourself because you need to use
+    # those special characters, then just include this in your chain.
+    #
+    #   Model.dont_escape.where("(some stuff I don\'t want escaped)")
+    #
+    # Note that fulltext searches are NEVER escaped.  Use Relation.solr_escape if you
+    # want that done.
+    def dont_escape
+      clone.tap do |r|
+        r.escape_value = false
+      end
+    end
+    
+    # Used to extend a scope with additional methods, either through 
+    # a module or a block provided
+    #
+    # The object returned is a relation which can be further extended
+    def extending(*modules)
+      modules << Module.new(&Proc.new) if block_given?
+
+      return self if modules.empty?
+
+      clone.tap do |r|
+        r.send(:apply_modules, modules.flatten)
+      end
+    end
+    
+    # Limit a single page to +value+ records
+    #
+    #   Model.limit(1)
+    #   Model.per_page(50)
+    #
+    # Normally DatastaxRails searches are paginated at a really high number
+    # so as to effectively disable pagination.  However, you can cause
+    # all requests to be paginated on a per-model basis by overriding the
+    # +default_page_size+ class method in your model:
+    #
+    #   class Model < DatastaxRails::Base
+    #     def self.default_page_size
+    #       30
+    #     end
+    #   end
+    def limit(value)
+      clone.tap do |r|
+        r.per_page_value = value
+      end
+    end
+    alias :per_page :limit
+    
+    # Sets the page number to retrieve
+    #
+    #   Model.page(2)
+    def page(value)
+      clone.tap do |r|
+        r.page_value = value
+      end
+    end
+    
+    # WillPaginate compatible method for paginating
+    #
+    #   Model.paginate(:page => 2, :per_page => 10)
+    def paginate(options = {})
+      options = options.reverse_merge({:page => 1, :per_page => 30})
+      clone.tap do |r|
+        r.page_value = options[:page]
+        r.per_page_value = options[:per_page]
+      end
+    end
+    
+    # Group results by one or more attributes only returning the top result
+    # for each group.
+    #
+    #   Model.group(:program_id)
+    def group(*attrs)
+      return self if attrs.blank?
+      
+      clone.tap do |r|
+        r.group_values += args.flatten
+      end
+    end
+    
+    # Orders the result set by a particular attribute.  Note that text fields
+    # may not be used for ordering as they are tokenized.  Valid candidates
+    # are fields of type +string+, +integer+, +long+, +float+, +double+, and
+    # +time+.  In addition, the symbol +:score+ can be used to sort on the 
+    # relevance rating returned by Solr.  The default direction is ascending
+    # but may be reversed by passing a hash where the field is the key and
+    # the value is :desc
+    #
+    #   Model.order(:name)
+    #   Model.order(:name => :desc)
+    def order(attribute)
+      return self if attribute.blank?
+
+      clone.tap do |r|
+        order_by = attribute.is_a?(Hash) ? attribute.dup : {attribute => :asc}
+        
+        r.order_values << order_by 
+      end
+    end
+    
+    # Works in two unique ways.
+    #
+    # _First_: takes a block so it can be used just like Array#select.
+    #
+    #   Model.scoped.select { |m| m.field == value }
+    #
+    # This will build an array of objects from the database for the scope,
+    # converting them into an array and iterating through them using Array#select.
+    #
+    # _Second_: Modifies the query so that only certain fields are retrieved:
+    #
+    #   >> Model.select(:field)
+    #   => [#<Model field:value>]
+    #
+    # Although in the above example it looks as though this method returns an
+    # array, it actually returns a relation object and can have other query
+    # methods appended to it, such as the other methods in DatastaxRails::SearchMethods.
+    #
+    # This method will also take multiple parameters:
+    #
+    #   >> Model.select(:field, :other_field, :and_one_more)
+    #   => [#<Model field: "value", other_field: "value", and_one_more: "value">]
+    #
+    # Any attributes that do not have fields retrieved by a select
+    # will return `nil` when the getter method for that attribute is used:
+    #
+    #   >> Model.select(:field).first.other_field
+    #   => nil
+    #
+    # The exception to this rule is when an attribute is lazy-loaded (e.g., binary).
+    # In that case, it is never retrieved until you call the getter method.
+    def select(value = Proc.new)
+      if block_given?
+        to_a.select {|*block_args| value.call(*block_args) }
+      else
+        clone.tap do |r|
+          r.select_values += Array.wrap(value)
+        end
+      end
+    end
+    
+    # Reverses the order of the results
+    # 
+    #   Model.order(:name).reverse_order
+    #     is equivalent to
+    #   Model.order(:name => :desc)
+    #
+    #   Model.order(:name).reverse_order.reverse_order
+    #     is equivalent to
+    #   Model.order(:name => :asc)
+    def reverse_order
+      clone.tap do |r|
+        r.reverse_order_value == !r.reverse_order_value
+      end
+    end
+    
+    # By default, DatastaxRails uses the LuceneQueryParser.  Note that this
+    # is a change from the underlying Sunspot gem.  Sunspot defaults to the
+    # +disMax+ query parser.  If you want to use that, then pass that in here.
+    #
+    # *This only applies to fulltext queries*
+    #
+    #   Model.query_parser('disMax').fulltext("john smith")
+    def query_parser(attribute)
+      return self if attribute.blank?
+      
+      clone.tap do |r|
+        r.query_parser_value = attribute
+      end
+    end
+    
+    # By default, DatastaxRails will try to pick the right method of performing
+    # a search.  You can use this method to force it to make the query via SOLR.
+    #
+    # NOTE that the time between when a record is placed into Cassandra and when
+    # it becomes available in SOLR is not guaranteed to be insignificant.  It's
+    # very possible to insert a new record and not find it when immediately doing
+    # a SOLR search for it.
+    def with_solr
+      clone.tap do |r|
+        r.use_solr_value = true
+      end
+    end
+    
+    # By default, DatastaxRails will try to pick the right method of performing
+    # a search.  You can use this method to force it to make the query via
+    # cassandra.
+    #
+    # NOTE that this method assumes that you have all the proper secondary indexes
+    # in place before you attempt to use it.  If not, you will get an error. 
+    def with_cassandra
+      clone.tap do |r|
+        r.use_solr_value = false
+      end
+    end
+    
+    # Specifies restrictions (scoping) on the result set. Expects a hash
+    # in the form +attribute => value+ for equality comparisons.
+    #
+    #   Model.where(:group_id => '1234', :active => 'Y')
+    #
+    # The value of the comparison does not need to be a scalar.  For example:
+    #
+    #   Model.where(:name => ["Bob", "Tom", "Sally"])
+    #   Model.where(:age => 18..65)
+    #
+    # Inequality comparisons such as greater_than and less_than are
+    # specified via chaining:
+    #
+    #   Model.where(:created_at).greater_than(1.day.ago)
+    #   Model.where(:age).less_than(65)
+    #
+    # NOTE: Due to the way SOLR handles range queries, all greater/less than
+    #       queries are actually greater/less than or equal to queries.
+    #       There is no way to perform a strictly greater/less than query.
+    def where(attribute)
+      return self if attribute.blank?
+      
+      if attribute.is_a?(Symbol)
+        WhereProxy.new(self, attribute)
+      else
+        attributes = attribute.dup
+        attributes.each do |k,v|
+          attributes[k] = solr_format(v)
+        end
+        clone.tap do |r|
+          r.where_values << attributes
+        end
+      end
+    end
+    
+    # Specifies restrictions (scoping) that should not match the result set.
+    # Expects a hash in the form +attribute => value+.
+    #
+    #   Model.where_not(:group_id => '1234', :active => 'N')
+    #
+    # Passing an array will search for records where none of the array entries
+    # are present
+    #
+    #   Model.where_not(:group_id => ['1234', '5678'])
+    #
+    # The above would find all models where group id is neither 1234 or 5678.
+    def where_not(attribute)
+      return self if attribute.blank?
+      
+      attributes = []
+      attribute.each do |k,v|
+        if v.is_a?(Array)
+          v.each do |val|
+            attributes << {k => solr_format(val)}
+          end
+        else
+          attributes << {k => solr_format(v)}
+        end
+      end
+      clone.tap do |r|
+        r.where_not_values += attributes
+      end
+    end
+    
+    # Specifies a full text search string to be processed by SOLR
+    #
+    #   Model.fulltext("john smith")
+    #
+    # You can also pass in an options hash with the following options:
+    #
+    #  * :fields => list of fields to search instead of the default of all fields
+    #  * :highlight => List of fields to retrieve highlights for.  Note that highlighted fields *must* be +:stored+
+    #
+    #   Model.fulltext("john smith", :fields => [:title])
+    #   Model.fulltext("john smith", :hightlight => [:body])
+    def fulltext(query, opts = {})
+      return self if query.blank?
+      
+      opts[:query] = query
+      
+      clone.tap do |r|
+        r.fulltext_values << opts
+      end
+    end
+    
+    # See documentation for +where+
+    def less_than(value)
+      raise ArgumentError, "#less_than can only be called after an appropriate where call. e.g. where(:created_at).less_than(1.day.ago)"
+    end
+    
+    # See documentation for +where+
+    def greater_than(value)
+      raise ArgumentError, "#greater_than can only be called after an appropriate where call. e.g. where(:created_at).greater_than(1.day.ago)"
+    end
+    
+    def solr_format(value)
+      case
+        when value.is_a?(Date), value.is_a?(Time)
+          value.strftime('%Y-%m-%dT%H\:%M\:%SZ')
+        when value.is_a?(Array)
+          value.collect {|v| v.gsub(/ /,"\\ ") }.join(" OR ")
+        when value.is_a?(Fixnum)
+          value < 0 ? "\\#{value}" : value
+        when value.is_a?(String)
+          value.gsub(/ /,"\\ ")
+        else
+          value
+      end
+    end
+    
+    protected
+      def find_by_attributes(match, attributes, *args) #:nodoc:
+        conditions = Hash[attributes.map {|a| [a, args[attributes.index(a)]]}]
+        result = where(conditions).send(match.finder)
+        
+        if match.blank? && result.blank?
+          raise RecordNotFound, "Couldn't find #{klass.name} with #{conditions.to_a.collect {|p| p.join('=')}.join(', ')}"
+        else
+          yield(result) if block_given?
+          result
+        end
+      end
+    
+    class WhereProxy #:nodoc:
+      def initialize(relation, attribute) #:nodoc:
+        @relation, @attribute = relation, attribute
+      end
+      
+      def equal_to(value) #:nodoc:
+        @relation.clone.tap do |r|
+          r.where_values << {@attribute => r.solr_format(value)}
+        end
+      end
+      
+      def greater_than(value) #:nodoc:
+        @relation.clone.tap do |r|
+          r.greater_than_values << {@attribute => r.solr_format(value)}
+        end
+      end
+      
+      def less_than(value) #:nodoc:
+        @relation.clone.tap do |r|
+          r.less_than_values << {@attribute => r.solr_format(value)}
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails/relation/spawn_methods.rb

@@ -0,0 +1,107 @@
+module DatastaxRails
+  module SpawnMethods
+    # def scoped #:nodoc:
+      # self
+    # end
+    
+    def merge(r) #:nodoc:
+      return self unless r
+      return to_a & r if r.is_a?(Array)
+      
+      merged_relation = clone
+      
+      (Relation::MULTI_VALUE_METHODS - [:where, :where_not]).each do |method|
+        value = r.send(:"#{method}_values")
+        merged_relation.send(:"#{method}_values=", merged_relation.send(:"#{method}_values") + value) if value.present?
+      end
+      
+      merged_wheres = {}
+      # This will merge all the where clauses into a single hash.  If the same attribute is
+      # specified multiple times, the last one will win.
+      (@where_values + r.where_values).each { |w| merged_wheres.merge!(w)}
+      
+      merged_relation.where_values = [merged_wheres] unless merged_wheres.empty?
+      
+      merged_where_nots = {}
+      # This will merge all the where not clauses into a single hash.  If the same attribute is
+      # specified multiple times, the last one will win.
+      (@where_not_values + r.where_not_values).each { |w| merged_where_nots.merge!(w)}
+      
+      merged_relation.where_not_values = [merged_where_nots] unless merged_where_nots.empty?
+      
+      (Relation::SINGLE_VALUE_METHODS).each do |method|
+        value = r.send(:"#{method}_value")
+        merged_relation.send(:"#{method}_value=", value) unless value.nil?
+      end
+      
+      merged_relation
+    end
+    
+    # Removes from the query the condition(s) specified in +skips+.
+    #
+    # Example:
+    #
+    #   Post.where(:active => true).order('id').except(:order) # discards the order condition
+    #   Post.where(:active => true).order('id').except(:where) # discards the where condition but keeps the order
+    def except(*skips)
+      result = self.class.new(@klass, table)
+      result.default_scoped = default_scoped
+
+      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - skips).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values"))
+      end
+
+      (Relation::SINGLE_VALUE_METHODS - skips).each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value"))
+      end
+
+      # Apply scope extension modules
+      result.send(:apply_modules, extensions)
+
+      result
+    end
+    
+    # Removes any condition from the query other than the one(s) specified in +onlies+.
+    #
+    # Example:
+    #
+    #   Post.order('id').only(:where)         # discards the order condition
+    #   Post.order('id').only(:where, :order) # uses the specified order
+    #
+    def only(*onlies)
+      result = self.class.new(@klass, table)
+      result.default_scoped = default_scoped
+
+      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) & onlies).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values"))
+      end
+
+      (Relation::SINGLE_VALUE_METHODS & onlies).each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value"))
+      end
+
+      # Apply scope extension modules
+      result.send(:apply_modules, extensions)
+
+      result
+    end
+    
+    VALID_FIND_OPTIONS = [:conditions, :limit, :offset, :order, :group, :page, :per_page]
+    def apply_finder_options(options) #:nodoc:
+      relation = clone
+      return relation unless options
+      
+      options.assert_valid_keys(VALID_FIND_OPTIONS)
+      finders = options.dup
+      finders.delete_if { |key, value| value.nil? }
+      
+      ([:group, :order, :limit, :offset, :page, :per_page] & finders.keys).each do |finder|
+        relation = relation.send(finder, finders[finder])
+      end
+      
+      relation.where(finders[:conditions]) if options.has_key?(:conditions)
+      
+      relation
+    end
+  end
+end