datastax_rails 1.0.8 → 1.0.10

data/lib/datastax_rails/associations/belongs_to_association.rb

@@ -29,6 +29,7 @@ module DatastaxRails
         end
         
         def replace_keys(record)
+          owner.loaded_attributes[reflection.foreign_key] = true
           owner.send("#{reflection.foreign_key}_will_change!")
           if record
             owner[reflection.foreign_key] = record.id

data/lib/datastax_rails/attribute_methods/definition.rb

@@ -12,7 +12,7 @@ module DatastaxRails
         value ||= coder.default
         return unless value
       
-        value = value.kind_of?(String) ? coder.decode(value) : value
+        value = (value.kind_of?(String) || value.kind_of?(Array)) ? coder.decode(value) : value
         coder.wrap(record, name, value)
       end
     end

data/lib/datastax_rails/attribute_methods/dirty.rb

@@ -31,6 +31,7 @@ module DatastaxRails
 
       def write_attribute(name, value)
         name = name.to_s
+        loaded_attributes[name] = true
         old = read_attribute(name)
         super
 

data/lib/datastax_rails/attribute_methods/typecasting.rb

@@ -37,6 +37,14 @@ module DatastaxRails
           self.models << child
         end
 
+        # Casts a single attribute according to the appropriate coder.
+        #
+        # @param [DatastaxRails::Base] record the record to which this attribute belongs
+        # @param [String] name the name of the attribute
+        # @param [Object] value the value of the attribute prior to typecasting
+        #
+        # @return the typecasted value
+        # @raise [NoMethodError] if the attribute is unknown
         def typecast_attribute(record, name, value)
           if attribute_definition = attribute_definitions[name.to_sym]
             attribute_definition.instantiate(record, value)

data/lib/datastax_rails/attribute_methods.rb

@@ -51,13 +51,17 @@ module DatastaxRails
       end
     end
     
+    # Casts the attribute and stores it in the attribute hash.
     def write_attribute(name, value)
       @attributes[name.to_s] = self.class.typecast_attribute(self, name, value)
     end
 
+    # Returns the attribute out of the attribute hash.  If the attribute is lazy loaded and hasn't
+    # been loaded yet it will be done so now.
     def read_attribute(name)
-      if(lazy_attributes.include?(name.to_sym) && @attributes[name.to_s].nil? && persisted?)
+      if(!loaded_attributes[name] && persisted? && !key.blank?)
         @attributes[name.to_s] = self.class.select(name).with_cassandra.find(self.id).read_attribute(name)
+        loaded_attributes[name] = true
       end
         
       @attributes[name.to_s]

data/lib/datastax_rails/base.rb

@@ -318,11 +318,13 @@ module DatastaxRails #:nodoc:
     self.models = []
     
     attr_reader :attributes
+    attr_reader :loaded_attributes
     attr_accessor :key
     
     def initialize(attributes = {}, options = {})
       @key = attributes.delete(:key)
-      @attributes = {}
+      @attributes = {}.with_indifferent_access
+      @loaded_attributes = {}.with_indifferent_access
       
       @relation = nil
       @new_record = true

data/lib/datastax_rails/cql/select.rb

@@ -44,6 +44,7 @@ module DatastaxRails#:nodoc:
         if @limit
           stmt << "LIMIT #{@limit}"
         end
+        
         CassandraCQL::Statement.sanitize(stmt, values)
       end
     end

data/lib/datastax_rails/identity/abstract_key_factory.rb

@@ -5,8 +5,9 @@ module DatastaxRails
       # Next key takes an object and returns the key object it should use.
       # object will be ignored with synthetic keys but could be useful with natural ones
       #
-      # @param  [CassandraObject::Base] the object that needs a new key
-      # @return [CassandraObject::Identity::Key] the key
+      # @abstract
+      # @param  [DatastaxRails::Base] object the object that needs a new key
+      # @return [DatastaxRails::Identity::Key] the key
       #
       def next_key(object)
         raise NotImplementedError, "#{self.class.name}#next_key isn't implemented."
@@ -14,8 +15,9 @@ module DatastaxRails
 
       # Parse should create a new key object from the 'to_param' format
       #
-      # @param  [String] the result of calling key.to_param
-      # @return [CassandraObject::Identity::Key] the parsed key
+      # @abstract
+      # @param  [String] string the result of calling key.to_param
+      # @return [DatastaxRails::Identity::Key] the parsed key
       #
       def parse(string)
         raise NotImplementedError, "#{self.class.name}#parse isn't implemented."

data/lib/datastax_rails/identity.rb

@@ -13,8 +13,8 @@ module DatastaxRails #:nodoc:
     module ClassMethods
       # Indicate what kind of key the model will have: uuid or natural
       #
-      # @param [:uuid, :natural] the type of key
-      # @param the options you want to pass along to the key factory (like :attributes => :name, for a natural key).
+      # @param [:uuid, :natural] name_or_factory the type of key
+      # @param [Hash] options the options you want to pass along to the key factory (like :attributes => :name, for a natural key).
       # 
       def key(name_or_factory = :uuid, *options)
         @key_factory = case name_or_factory
@@ -29,12 +29,22 @@ module DatastaxRails #:nodoc:
         end
       end
 
+      # The next key for the given object. Delegates the actual work to the factory which may
+      # or may not use the passed in object to generate the key.
+      #
+      # @param [DatastaxRails::Base] object the object for which the key is being generated
+      # @return [String] a key for this object
       def next_key(object = nil)
         @key_factory.next_key(object).tap do |key|
           raise "Keys may not be nil" if key.nil?
         end
       end
 
+      # Parses out a key from the given string. Delegates the actual work to the factory.
+      # Return type varies depending on what type of key is used.
+      #
+      # @param [String] string a string representing a primary key
+      # @return an object representing the same key
       def parse_key(string)
         @key_factory.parse(string)
       end

data/lib/datastax_rails/persistence.rb

@@ -7,7 +7,18 @@ module DatastaxRails
     end
     
     module ClassMethods
-      # Removes one or more records with corresponding keys
+      # Removes one or more records with corresponding keys.  Last parameter can be a hash
+      # specifying the consistency level.
+      #
+      #   Model.remove('12345','67890', :consistency => 'LOCAL_QUORUM)
+      #
+      # @overload remove(*keys, options)
+      #   Removes one or more keys with the given options
+      #   @param [String] keys one or more keys to delete
+      #   @param [Hash] options generally the consistency level to set
+      # @overload remove(*keys)
+      #   Removes one or more keys with the default options
+      #   @param [String] keys one or more keys to delete
       def remove(*keys)
         options = {}
         if keys.last.is_a?(Hash)
@@ -28,12 +39,12 @@ module DatastaxRails
       end
 
       # Truncates the column_family associated with this class
-      def delete_all
+      def truncate
         ActiveSupport::Notifications.instrument("truncate.datastax_rails", :column_family => column_family) do
           cql.truncate.execute
         end
       end
-      alias :truncate :delete_all
+      alias :delete_all :truncate
 
       def create(attributes = {}, options = {}, &block)
         new(attributes, &block).tap do |object|
@@ -41,6 +52,13 @@ module DatastaxRails
         end
       end
       
+      # 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 [Hash] options a hash containing various options
+      # @option options [Symbol] :consistency the consistency to set for the Cassandra operation (e.g., ALL)
+      # @option options [String] :schema_version the version of the schema to set for this record
       def write(key, attributes, options = {})
         key.tap do |key|
           attributes = encode_attributes(attributes, options[:schema_version])
@@ -59,13 +77,14 @@ module DatastaxRails
         end
       end
 
-      def instantiate(key, attributes)
+      def instantiate(key, attributes, selected_attributes = [])
         allocate.tap do |object|
+          object.instance_variable_set("@loaded_attributes", {}.with_indifferent_access)
           object.instance_variable_set("@schema_version", attributes.delete('schema_version'))
           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))
+          object.instance_variable_set("@attributes", typecast_attributes(object, attributes, selected_attributes))
         end
       end
 
@@ -75,15 +94,37 @@ module DatastaxRails
           if value.nil?
             encoded[column_name.to_s] = ""
           else
-            encoded[column_name.to_s] = attribute_definitions[column_name.to_sym].coder.encode(value)
+            encoded_value = attribute_definitions[column_name.to_sym].coder.encode(value)
+            if(encoded_value.is_a?(Array))
+              encoded_value.each_with_index do |chunk,i|
+                encoded[column_name.to_s + "_chunk_#{'%05d' % i}"] = chunk
+              end
+            else
+              encoded[column_name.to_s] = encoded_value
+            end
           end
         end
         encoded
       end
 
-      def typecast_attributes(object, attributes)
+      def typecast_attributes(object, attributes, selected_attributes = [])
         attributes = attributes.symbolize_keys
-        Hash[attribute_definitions.map { |k, attribute_definition| [k.to_s, attribute_definition.instantiate(object, attributes[k])] }]
+        casted = {}
+        
+        selected_attributes.each do |att|
+          object.loaded_attributes[att] = true
+        end
+        
+        attribute_definitions.each do |k,definition|
+          if(definition.coder.is_a?(DatastaxRails::Types::BinaryType))
+            # Need to handle possibly chunked data
+            chunks = attributes.select {|key,value| key.to_s =~ /#{k.to_s}_chunk_\d+/ }.sort {|a,b| a.first.to_s <=> b.first.to_s}.collect {|c| c.last}
+            casted[k.to_s] = definition.instantiate(object, chunks)
+          else
+            casted[k.to_s] = definition.instantiate(object, attributes[k])
+          end
+        end
+        casted
       end
     end
 

data/lib/datastax_rails/reflection.rb

@@ -131,7 +131,7 @@ module DatastaxRails
 
     # Holds all the meta-data about an association as it was specified in the
     # DatastaxRails class.
-    class AssociationReflection < MacroReflection #:nodoc:
+    class AssociationReflection < MacroReflection
       # Returns the target association's class.
       #
       #   class Author < DatastaxRails::Base

data/lib/datastax_rails/relation.rb

@@ -222,14 +222,22 @@ 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)
+      select = []
+      select_columns.each do |col|
+        if @klass.attribute_definitions[col.to_sym] && @klass.attribute_definitions[col.to_sym].coder.is_a?(DatastaxRails::Types::BinaryType)
+          select << "'#{col}_chunk_00000' .. '#{col}_chunk_99999'"
+        else
+          select << col
+        end
+      end
+      cql = @cql.select(select)
       cql.using(@consistency_value) if @consistency_value
       @where_values.each do |wv|
         cql.conditions(wv)
       end
       results = []
       CassandraCQL::Result.new(cql.execute).fetch do |row|
-        results << @klass.instantiate(row.row.key,row.to_hash)
+        results << @klass.instantiate(row.row.key, row.to_hash, select_columns)
       end
       results
     end
@@ -315,6 +323,8 @@ module DatastaxRails
         params[:fq] = filter_queries
       end
       
+      select_columns = select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
+      
       #TODO Need to escape URL stuff (I think)
       response = rsolr.paginate(@page_value, @per_page_value, 'select', :params => params)["response"]
       results = DatastaxRails::Collection.new
@@ -328,7 +338,7 @@ module DatastaxRails
       else
         response['docs'].each do |doc|
           key = doc.delete('id')
-          results << @klass.instantiate(key,doc)
+          results << @klass.instantiate(key,doc, select_columns)
         end
       end
       results

data/lib/datastax_rails/types/binary_type.rb

@@ -4,7 +4,25 @@ module DatastaxRails
       DEFAULTS = {:solr_type => false, :indexed => false, :stored => false, :multi_valued => false, :sortable => false, :tokenized => false, :fulltext => false}
       def encode(str)
         raise ArgumentError.new("#{self} requires a String") unless str.kind_of?(String)
-        str.dup
+        io = StringIO.new(Base64.encode64(str))
+        chunks = []
+        while chunk = io.read(1.megabyte)
+          chunks << chunk
+        end
+        chunks
+      end
+      
+      def decode(arr)
+        if(arr.is_a?(Array))
+          io = StringIO.new("","w+")
+          arr.each do |chunk|
+            io.write(chunk)
+          end
+          io.rewind
+          Base64.decode64(io.read)
+        else
+          arr
+        end
       end
 
       def wrap(record, name, value)

data/lib/datastax_rails/version.rb

@@ -1,4 +1,4 @@
 module DatastaxRails
   # The current version of the gem
-  VERSION = "1.0.8"
+  VERSION = "1.0.10"
 end