datastax_rails 1.2.3 → 2.0.3

data/lib/datastax_rails/persistence.rb

@@ -20,7 +20,8 @@ module DatastaxRails
         if keys.last.is_a?(Hash)
           options = keys.pop
         end
-        ActiveSupport::Notifications.instrument("remove.datastax_rails", :column_family => column_family, :key => key) do
+        keys = keys.flatten.collect {|k| self.attribute_definitions[self.primary_key].type_cast(k)}
+        ActiveSupport::Notifications.instrument("remove.datastax_rails", :column_family => column_family, :key => keys) do
           c = cql.delete(keys)
           if(options[:consistency])
             level = options[:consistency].to_s.upcase
@@ -50,24 +51,22 @@ module DatastaxRails
       
       # Write a record to cassandra.  Can be either an insert or an update (they are exactly the same to cassandra)
       #
-      # @param [String] key the primary key for the record
-      # @param [Hash] attributes a hash containing the columns to set on the record
+      # @param [DatastaxRails::Base] record the record that we are writing
       # @param [Hash] options a hash containing various options
       # @option options [Symbol] :consistency the consistency to set for the Cassandra operation (e.g., ALL)
-      def write(key, attributes, options = {})
-        attributes = encode_attributes(attributes)
+      def write(record, options = {})
         level = (options[:consistency] || self.default_consistency).to_s.upcase
         if(valid_consistency?(level))
           options[:consistency] = level
         else
           raise ArgumentError, "'#{level}' is not a valid Cassandra consistency level"
         end
-        key.tap do |key|
-          ActiveSupport::Notifications.instrument("insert.datastax_rails", :column_family => column_family, :key => key, :attributes => attributes) do
+        record.id.tap do |key|
+          ActiveSupport::Notifications.instrument("insert.datastax_rails", :column_family => column_family, :key => key.to_s, :attributes => record.attributes) do
             if(self.storage_method == :solr)
-              write_with_solr(key, attributes, options)
+              write_with_solr(record, options)
             else
-              write_with_cql(key, attributes, options)
+              write_with_cql(record, options)
             end
           end
         end
@@ -81,49 +80,40 @@ module DatastaxRails
       #   to build this object.  Used so that we can avoid lazy-loading attributes that don't exist.
       # @return [DatastaxRails::Base] a model with the given attributes
       def instantiate(key, attributes, selected_attributes = [])
-        allocate.tap do |object|
-          object.instance_variable_set("@loaded_attributes", {}.with_indifferent_access)
-          object.instance_variable_set("@key", parse_key(key)) if key
-          object.instance_variable_set("@new_record", false)
-          object.instance_variable_set("@destroyed", false)
-          object.instance_variable_set("@attributes", typecast_attributes(object, attributes, selected_attributes).with_indifferent_access)
-        end
+        allocate.init_with('attributes' => attributes)
       end
-
+      
       # Encodes the attributes in preparation for storing in cassandra. Calls the coders on the various type classes
       # to do the heavy lifting.
       #
-      # @param [Hash] attributes a hash containing the attributes to be encoded for storage
+      # @param [DatastaxRails::Base] record the record whose attributes we're encoding
+      # @param [Boolean] cql True if we're formatting for CQL, otherwise False
       # @return [Hash] a new hash with attributes encoded for storage
-      def encode_attributes(attributes)
+      def encode_attributes(record, cql)
         encoded = {}
-        attributes.each do |column_name, value|
-            encoded[column_name.to_s] = attribute_definitions[column_name.to_sym].coder.encode(value)
+        Types::DirtyCollection.ignore_modifications do
+          record.changed.each do |column_name|
+            value = record.read_attribute(column_name)
+            encoded[column_name.to_s] = cql ? attribute_definitions[column_name].type_cast_for_cql3(value) :
+                                              attribute_definitions[column_name].type_cast_for_solr(value)
+          end
         end
         encoded
       end
-
-      def typecast_attributes(object, attributes, selected_attributes = [])
-        attributes = attributes.symbolize_keys
-        casted = {}
-        
-        selected_attributes.each do |att|
-          object.loaded_attributes[att] = true
-        end
-        
-        attribute_definitions.each do |k,definition|
-          casted[k.to_s] = definition.instantiate(object, attributes[k.to_sym])#.to_s
-        end
-        casted
-      end
       
       private
-        def write_with_cql(key, attributes, options)
-          cql.update(key.to_s).columns(attributes).using(options[:consistency]).execute
+        def write_with_cql(record, options)
+          encoded = encode_attributes(record, true)
+          if options[:new_record]
+            cql.insert.columns(encoded).using(options[:consistency]).execute
+          else
+            cql.update(record.id).columns(encoded).using(options[:consistency]).execute
+          end
         end
         
-        def write_with_solr(key, attributes, options)
-          xml_doc = RSolr::Xml::Generator.new.add(attributes.merge(:id => key))
+        def write_with_solr(record, options)
+          encoded = encode_attributes(record, false)
+          xml_doc = RSolr::Xml::Generator.new.add(encoded.merge(self.primary_key => record.id.to_s))
           self.solr_connection.update(:data => xml_doc, :params => {:replacefields => false, :cl => options[:consistency]})
         end
     end
@@ -153,7 +143,7 @@ module DatastaxRails
     end
 
     def destroy(options = {})
-      self.class.remove(key, options)
+      self.class.remove(id, options)
       @destroyed = true
       freeze
     end
@@ -173,20 +163,15 @@ module DatastaxRails
 
     # Updates the attributes of the model from the passed-in hash and saves the
     # record If the object is invalid, the saving will fail and false will be returned.
-    #
-    # When updating model attributes, mass-assignment security protection is respected.
-    # If no +:as+ option is supplied then the +:default+ role will be used.
-    # If you want to bypass the protection given by +attr_protected+ and
-    # +attr_accessible+ then you can do so using the +:without_protection+ option.
     def update_attributes(attributes, options = {})
-      self.assign_attributes(attributes, options)
+      self.assign_attributes(attributes)
       save
     end
 
     # Updates its receiver just like +update_attributes+ but calls <tt>save!</tt> instead
     # of +save+, so an exception is raised if the record is invalid.
     def update_attributes!(attributes, options = {})
-      self.assign_attributes(attributes, options)
+      self.assign_attributes(attributes)
       save!
     end
     
@@ -223,26 +208,26 @@ module DatastaxRails
 
     private
       def _create_or_update(options)
-        result = new_record? ? _create(options) : _update(options)
+        result = new_record? ? _create_record(options) : _update_record(options)
         result != false
       end
 
-      def _create(options)
-        @key ||= self.class.next_key(self)
+      def _create_record(options)
+        # TODO: handle the non-UUID case
+        self.id ||= ::Cql::TimeUuid::Generator.new.next
         _write(options)
         @new_record = false
-        @key
+        self.id
       end
     
-      def _update(options)
+      def _update_record(options)
         _write(options)
       end
       
       def _write(options) #:nodoc:
         options[:new_record] = new_record?
-        changed_attributes = changed.inject({}) { |h, n| h[n] = read_attribute(n); h }
         return true if changed_attributes.empty?
-        self.class.write(key, changed_attributes, options)
+        self.class.write(self, options)
       end
   end
 end

data/lib/datastax_rails/railtie.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'datastax_rails'
 require 'rails'
 require 'action_controller/railtie'
+require 'yaml'
 
 module DatastaxRails
   class Railtie < Rails::Railtie

data/lib/datastax_rails/reflection.rb

@@ -314,7 +314,7 @@ module DatastaxRails
       # Gets the source of the through reflection.  It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
       #
-      #   class Post < ActiveRecord::Base
+      #   class Post < DatastaxRails::Base
       #     has_many :taggings
       #     has_many :tags, :through => :taggings
       #   end

data/lib/datastax_rails/relation.rb

@@ -250,8 +250,6 @@ module DatastaxRails
       when true
         return :solr
       else
-        # If we've already decided to use cassandra, just go with it.
-        return :cassandra unless use_solr_value
         [order_values, where_not_values, fulltext_values, greater_than_values, less_than_values, field_facet_values,
          range_facet_values, group_value].each do |solr_only_stuff|
            return :solr unless solr_only_stuff.blank? 
@@ -260,8 +258,7 @@ module DatastaxRails
         return :solr unless page_value == 1
         @where_values.each do |wv|
           wv.each do |k,v|
-            next if k.to_sym == :id
-            if(klass.attribute_definitions[k].indexed == :solr || !klass.attribute_definitions[k].indexed)
+            unless klass.column_for_attribute(k).options[:cql_index]
               return :solr
             end
           end
@@ -292,7 +289,7 @@ module DatastaxRails
         cql.conditions(wv)
       end
       cql.allow_filtering if @allow_filtering_value
-      CassandraCQL::Result.new(cql.execute).fetch['count']
+      cql.execute.first['count']
     end
     
     # Constructs a CQL query and runs it against Cassandra directly.  For this to
@@ -300,15 +297,15 @@ module DatastaxRails
     # For ad-hoc queries, you will have to use Solr.
     def query_via_cql
       select_columns = select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
-      cql = @cql.select((select_columns + @klass.key_factory.key_columns).uniq)
+      cql = @cql.select((select_columns + [@klass.primary_key]).uniq)
       cql.using(@consistency_value) if @consistency_value
       @where_values.each do |wv|
-        cql.conditions(Hash[wv.map {|k,v| [(k.to_sym == :id ? :key : k), v]}])
+        cql.conditions(Hash[wv.map {|k,v| [(k.to_s == 'id' ? @klass.primary_key : k), v]}])
       end
       @greater_than_values.each do |gtv|
         gtv.each do |k,v|
           # Special case if inequality is equal to the primary key (we're paginating)
-          if(k == :key)
+          if(k.to_s == @klass.primary_key)
             cql.paginate(v)
           end
         end
@@ -319,10 +316,10 @@ module DatastaxRails
       cql.allow_filtering if @allow_filtering_value
       results = []
       begin
-        CassandraCQL::Result.new(cql.execute).fetch do |row|
-          results << @klass.instantiate(row['key'], row.to_hash, select_columns)
+        cql.execute.each do |row|
+          results << @klass.instantiate(row[@klass.primary_key], row, select_columns)
         end
-      rescue CassandraCQL::Error::InvalidRequestException => e
+      rescue ::Cql::CqlError => e # TODO: Break out the various exception types
         # If we get an exception about an empty key, ignore it.  We'll return an empty set.
         if e.message =~ /Key may not be empty/
           # No-Op
@@ -377,7 +374,7 @@ module DatastaxRails
     
     def full_solr_range(attr)
       if(self.klass.attribute_definitions[attr])
-        self.klass.attribute_definitions[attr].coder.full_solr_range
+        self.klass.attribute_definitions[attr].full_solr_range
       else
         '[\"\" TO *]'
       end
@@ -495,8 +492,9 @@ module DatastaxRails
       end
       
       select_columns = select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
-      select_columns << "id"
-      params[:fl] = select_columns.collect(&:to_s).join(",")
+      select_columns << @klass.primary_key
+      select_columns.collect! {|c| @klass.column_for_attribute(c).try(:type) == :map ? "#{c.to_s}*" : c.to_s}
+      params[:fl] = select_columns.uniq.join(",")
       unless(@stats_values.empty?)
         params[:stats] = 'true'
         @stats_values.flatten.each do |sv|
@@ -556,12 +554,11 @@ module DatastaxRails
       results.current_page = @page_value || 1
       results.total_entries = response['numFound'].to_i
       response['docs'].each do |doc|
-        id = doc['id']
+        id = @klass.attribute_definitions[@klass.primary_key].type_cast(doc[@klass.primary_key])
         if(@consistency_value)
           obj = @klass.with_cassandra.consistency(@consistency_value).find_by_id(id)
           results << obj if obj
         else
-          #byebug
           results << @klass.instantiate(id, doc, select_columns)
         end
       end
@@ -607,20 +604,23 @@ module DatastaxRails
       rsolr.commit :commit_attributes => {}
     end
     
+    SOLR_DATE_REGEX = /(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)/i
     # Everything that gets indexed into solr is downcased as part of the analysis phase.
     # Normally, this is done to the query as well, but if your query includes wildcards
     # then analysis isn't performed.  This means that the query does not get downcased.
     # We therefore need to perform the downcasing ourselves.  This does it while still
-    # leaving boolean operations (AND, OR, NOT) upcased.
+    # leaving boolean operations (AND, OR, NOT, TO) and dates upcased.
     def downcase_query(value)
       if(value.is_a?(String))
         value.split(/\bAND\b/).collect do |a|
           a.split(/\bOR\b/).collect do |o| 
-            o.split(/\bNOT\b/).collect do |n| 
-              n.downcase
+            o.split(/\bNOT\b/).collect do |n|
+              n.split(/\bTO\b/).collect do |t|
+                t.downcase
+              end.join("TO")
             end.join("NOT")
           end.join("OR")
-        end.join("AND")
+        end.join("AND").gsub(SOLR_DATE_REGEX) { $1.upcase }
       else
         value
       end

data/lib/datastax_rails/relation/batches.rb

@@ -6,7 +6,7 @@ module DatastaxRails
     #
     # Example:
     #
-    #   Person.where("age > 21").find_each do |person|
+    #   Person.where(in_college: true).find_each do |person|
     #     person.party_all_night!
     #   end
     #
@@ -15,6 +15,9 @@ module DatastaxRails
     # you just need to loop over less than 1000 records, it's probably
     # better just to use the regular find methods.
     #
+    # You can also pass the +:start+ option to specify an offset to
+    # control the starting point.
+    #
     # @param options [Hash] finder options
     # @yield [record] a single DatastaxRails record
     def find_each(options = {})
@@ -23,6 +26,7 @@ module DatastaxRails
       end
     end
     
+    # Same as {find_each} but yields the index as a second parameter.
     def find_each_with_index(options = {})
       idx = 0
       find_in_batches(options) do |records|
@@ -44,30 +48,29 @@ module DatastaxRails
     # worker 2 handle from 10,000 and beyond (by setting the <tt>:start</tt>
     # option on that worker).
     #
-    # It's not possible to set the order. That is automatically set according
-    # Cassandra's key placement strategy. Records are retrieved and returned
-    # using only Cassandra and no SOLR interaction. This also mean that this
-    # method only works with any type of primary key (unlike ActiveRecord).
-    # You can't set the limit, however. That's used to control the batch sizes.
+    # It's not possible to set the order. For Cassandra based batching, the
+    # order is set according to Cassandra's key placement strategy. For Solr
+    # based batching, the order is ascending order of the primary key. 
+    # You can't set the limit either. That's used to control the batch sizes.
     #
     # Example:
     #
-    #   Person.where("age > 21").find_in_batches do |group|
+    #   Person.where(in_college: true).find_in_batches do |group|
     #     sleep(50) # Make sure it doesn't get too crowded in there!
     #     group.each { |person| person.party_all_night! }
     #   end
     #
     # @param options [Hash] finder options
-    # @yeild [records] a batch of DatastaxRails records
+    # @yield [records] a batch of DatastaxRails records
     def find_in_batches(options = {})
       relation = self
 
-      unless (@order_values.empty? || @order_values == [{:created_at => :asc}])
+      unless (@order_values.empty?)
         DatastaxRails::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
       end
 
       if (finder_options = options.except(:start, :batch_size)).present?
-        raise "You can't specify an order, it's forced to be #{relation.use_solr_value ? "created_at" : "key"}" if options[:order].present?
+        raise "You can't specify an order, it's forced to be #{@klass.primary_key}" if options[:order].present?
         raise "You can't specify a limit, it's forced to be the batch_size" if options[:limit].present?
 
         relation = apply_finder_options(finder_options)
@@ -76,21 +79,20 @@ module DatastaxRails
       start = options.delete(:start)
       batch_size = options.delete(:batch_size) || 1000
       
-      batch_order = (relation.use_solr_value ? :created_at : :key)
       relation = relation.limit(batch_size)
-      relation = relation.order(batch_order) if relation.use_solr_value
-      records = start ? relation.where(batch_order).greater_than(start).to_a : relation.to_a
+      relation = relation.order(@klass.primary_key) if relation.use_solr_value
+      records = start ? relation.where(@klass.primary_key).greater_than(start).to_a : relation.to_a
       while records.size > 0
         records_size = records.size
-        offset = relation.use_solr_value ? records.last.created_at.to_time : records.last.id
+        offset = records.last.id
         yield records
 
         break if records_size < batch_size
         if offset
           if relation.use_solr_value
-            offset += 1
+            offset = ::Cql::Uuid.new(offset.value+1)
           end
-          records = relation.where(batch_order).greater_than(offset).to_a
+          records = relation.where(@klass.primary_key).greater_than(offset).to_a
         else
           raise "Batch order not included in the custom select clause"
         end

data/lib/datastax_rails/relation/facet_methods.rb

@@ -1,7 +1,7 @@
 module DatastaxRails
   module FacetMethods
     # Instructs SOLR to get facet counts on the passed in field.  Results are available in the facets accessor.
-    # Facets include Field and Range (Date is not supported as it is depricated in Solr).
+    # Facets include Field and Range (Date is not supported as it is depricated in Solr - use a range instead).
     #
     # results = Article.field_facet(:author)
     # results.facets => {"author"=>["vonnegut", 2. "asimov", 3]} 

data/lib/datastax_rails/relation/finder_methods.rb

@@ -140,15 +140,8 @@ module DatastaxRails
       def find_by_attributes(match, attributes, *args) #:nodoc:
        
         conditions =  Hash[attributes.map {|a| [a, args[attributes.index(a)]]}]
-        if Rails.version =~ /^3.*/
-          self.where_values << escape_attributes(conditions)
-          result = self.send(match.finder)
-        elsif Rails.version =~ /^4.*/
-          result = self.send(match.finder, conditions)
-        end
+        result = self.send(match.finder, conditions)
 
-        #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
@@ -191,11 +184,14 @@ module DatastaxRails
       end
       
       def find_one(id)
-        with_cassandra.where(:key => id).first || raise(RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}")
+        key = @klass.attribute_definitions[@klass.primary_key].type_cast(id) || raise(RecordNotFound, "Couldn't find #{@klass.name} with an invalid ID=#{id}")
+        
+        with_cassandra.where(@klass.primary_key => key).first || raise(RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}")
       end
   
       def find_some(ids)
-        result = with_cassandra.where(:key => ids).all
+        keys = ids.collect {|id| @klass.attribute_definitions[@klass.primary_key].type_cast(id) || "Couldn't find #{@klass.name} with an invalid ID=#{id}"}
+        result = with_cassandra.where(@klass.primary_key => keys).all
   
         expected_size =
           if @limit_value && ids.size > @limit_value