datastax_rails 1.2.3 → 2.0.3

data/lib/datastax_rails/attribute_methods/before_type_cast.rb

@@ -0,0 +1,71 @@
+module DatastaxRails
+  module AttributeMethods
+    # = Datastax Rails Attribute Methods Before Type Cast
+    #
+    # <tt>Datastax Rails::AttributeMethods::BeforeTypeCast</tt> provides a way to
+    # read the value of the attributes before typecasting and deserialization.
+    #
+    #   class Task < DatastaxRails::Base
+    #   end
+    #
+    #   task = Task.new(id: '1', completed_on: '2012-10-21')
+    #   task.id           # => 1
+    #   task.completed_on # => Sun, 21 Oct 2012
+    #
+    #   task.attributes_before_type_cast
+    #   # => {"id"=>"1", "completed_on"=>"2012-10-21", ... }
+    #   task.read_attribute_before_type_cast('id')           # => "1"
+    #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+    #
+    # In addition to #read_attribute_before_type_cast and #attributes_before_type_cast,
+    # it declares a method for all attributes with the <tt>*_before_type_cast</tt>
+    # suffix.
+    #
+    #   task.id_before_type_cast           # => "1"
+    #   task.completed_on_before_type_cast # => "2012-10-21"
+    module BeforeTypeCast
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "_before_type_cast"
+      end
+
+      # Returns the value of the attribute identified by +attr_name+ before
+      # typecasting and deserialization.
+      #
+      #   class Task < DatastaxRails::Base
+      #   end
+      #
+      #   task = Task.new(id: '1', completed_on: '2012-10-21')
+      #   task.read_attribute('id')                            # => 1
+      #   task.read_attribute_before_type_cast('id')           # => '1'
+      #   task.read_attribute('completed_on')                  # => Sun, 21 Oct 2012
+      #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+      #   task.read_attribute_before_type_cast(:completed_on)  # => "2012-10-21"
+      def read_attribute_before_type_cast(attr_name)
+        @attributes[attr_name.to_s]
+      end
+
+      # Returns a hash of attributes before typecasting and deserialization.
+      #
+      #   class Task < DatastaxRails::Base
+      #   end
+      #
+      #   task = Task.new(title: nil, is_done: true, completed_on: '2012-10-21')
+      #   task.attributes
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>Sun, 21 Oct 2012, "created_at"=>nil, "updated_at"=>nil}
+      #   task.attributes_before_type_cast
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>"2012-10-21", "created_at"=>nil, "updated_at"=>nil}
+      def attributes_before_type_cast
+        @attributes
+      end
+
+      private
+
+      # Handle *_before_type_cast for method_missing.
+      def attribute_before_type_cast(attribute_name)
+        read_attribute_before_type_cast(attribute_name)
+      end
+    end
+  end
+end

data/lib/datastax_rails/attribute_methods/dirty.rb

@@ -3,6 +3,12 @@ module DatastaxRails
     module Dirty
       extend ActiveSupport::Concern
       include ActiveModel::Dirty
+      
+      included do
+        if self < ::DatastaxRails::Timestamps
+          raise "You cannot include Dirty after Timestamps"
+        end
+      end
 
       # Attempts to +save+ the record and clears changed attributes if successful.
       def save(*) #:nodoc:
@@ -22,23 +28,58 @@ module DatastaxRails
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
-      def reload
+      def reload(*)
         super.tap do
-          @previously_changed.try :clear
-          @changed_attributes.try :clear
+          @previously_changed.clear
+          @changed_attributes.clear
         end
       end
 
-      def write_attribute(name, value)
-        name = name.to_s
-        loaded_attributes[name] = true
-        old = read_attribute(name)
-        super
-
-        unless attribute_changed?(name) || old == read_attribute(name)
-          changed_attributes[name] = old
+      def write_attribute(attr, value)
+        attr = attr.to_s
+        loaded_attributes[attr] = true
+        
+        # The attribute already has an unsaved change.
+        if attribute_changed?(attr)
+          old = @changed_attributes[attr]
+          @changed_attributes.delete(attr) unless _field_changed?(attr, old, value)
+        else
+          old = clone_attribute_value(:read_attribute, attr)
+          @changed_attributes[attr] = old if _field_changed?(attr, old, value)
         end
+        
+        super
       end
+      
+      private
+        def _field_changed?(attr, old, value)
+          if column = column_for_attribute(attr)
+            if column.number? && (changes_from_nil_to_empty_string?(column, old, value) ||
+                                  changes_from_zero_to_string?(old, value))
+              value = nil
+            else
+              value = column.type_cast(value, self)
+            end
+          end
+  
+          old != value
+        end
+        
+        def changes_from_nil_to_empty_string?(column, old, value)
+          # We don't record it as a change if the value changes from nil to ''.
+          # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
+          # be typecast back to 0 (''.to_i => 0)
+          (old.nil? || old == 0) && value.blank?
+        end
+  
+        def changes_from_zero_to_string?(old, value)
+          # For columns with old 0 and value non-empty string
+          old == 0 && value.is_a?(String) && value.present? && non_zero?(value)
+        end
+  
+        def non_zero?(value)
+          value !~ /\A0+(\.0+)?\z/
+        end
     end
   end
 end

data/lib/datastax_rails/attribute_methods/primary_key.rb

@@ -0,0 +1,87 @@
+require 'set'
+
+module DatastaxRails
+  module AttributeMethods
+    module PrimaryKey
+      extend ActiveSupport::Concern
+
+      # Returns this record's primary key value wrapped in an Array if one is
+      # available.
+      def to_key
+        key = self.id
+        [key] if key
+      end
+
+      # Returns the primary key value.
+      def id
+        read_attribute(self.class.primary_key)
+      end
+
+      # Sets the primary key value.
+      def id=(value)
+        write_attribute(self.class.primary_key, value) if self.class.primary_key
+      end
+
+      # Queries the primary key value.
+      def id?
+        query_attribute(self.class.primary_key)
+      end
+
+      # Returns the primary key value before type cast.
+      def id_before_type_cast
+        read_attribute_before_type_cast(self.class.primary_key)
+      end
+
+      protected
+
+      def attribute_method?(attr_name)
+        attr_name == 'id' || super
+      end
+
+      module ClassMethods
+        def define_method_attribute(attr_name)
+          super
+
+          if attr_name == primary_key && attr_name != 'id'
+            generated_attribute_methods.send(:alias_method, :id, primary_key)
+          end
+        end
+
+        ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast).to_set
+
+        # Defines the primary key field -- can be overridden in subclasses.
+        # Overwriting will negate any effect of the +primary_key_prefix_type+
+        # setting, though.
+        def primary_key
+          @primary_key || 'id'
+        end
+
+        # Returns a quoted version of the primary key name, used to construct
+        # CQL statements.
+        def quoted_primary_key
+          @quoted_primary_key ||= connection.quote_column_name(primary_key)
+        end
+
+        # Sets the name of the primary key column.
+        #
+        #   class Project < DatastaxRails::Base
+        #     self.primary_key = 'sysid'
+        #   end
+        #
+        # You can also define the +primary_key+ method yourself:
+        #
+        #   class Project < DatastaxRails::Base
+        #     def self.primary_key
+        #       'foo_' + super
+        #     end
+        #   end
+        #
+        #   Project.primary_key # => "foo_id"
+        def primary_key=(value)
+          @primary_key        = value && value.to_s
+          @quoted_primary_key = nil
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails/attribute_methods/read.rb

@@ -0,0 +1,120 @@
+module DatastaxRails
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+      ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
+
+      included do
+        class_attribute :attribute_types_cached_by_default, instance_writer: false
+        self.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
+      end
+
+      module ClassMethods
+        # +cache_attributes+ allows you to declare which converted attribute
+        # values should be cached. Usually caching only pays off for attributes
+        # with expensive conversion methods, like time related columns (e.g.
+        # +created_at+, +updated_at+).
+        def cache_attributes(*attribute_names)
+          cached_attributes.merge attribute_names.map { |attr| attr.to_s }
+        end
+
+        # Returns the attributes which are cached. By default time related columns
+        # with datatype <tt>:datetime, :timestamp, :time, :date</tt> are cached.
+        def cached_attributes
+          @cached_attributes ||= columns.select { |c| cacheable_column?(c) }.map { |col| col.name }.to_set
+        end
+
+        # Returns +true+ if the provided attribute is being cached.
+        def cache_attribute?(attr_name)
+          cached_attributes.include?(attr_name)
+        end
+
+        protected
+
+        # We want to generate the methods via module_eval rather than
+        # define_method, because define_method is slower on dispatch.
+        # Evaluating many similar methods may use more memory as the instruction
+        # sequences are duplicated and cached (in MRI).  define_method may
+        # be slower on dispatch, but if you're careful about the closure
+        # created, then define_method will consume much less memory.
+        #
+        # But sometimes the database might return columns with
+        # characters that are not allowed in normal method names (like
+        # 'my_column(omg)'. So to work around this we first define with
+        # the __temp__ identifier, and then use alias method to rename
+        # it to what we want.
+        #
+        # We are also defining a constant to hold the frozen string of
+        # the attribute name. Using a constant means that we do not have
+        # to allocate an object on each call to the attribute method.
+        # Making it frozen means that it doesn't get duped when used to
+        # key the @attributes_cache in read_attribute.
+        def define_method_attribute(name)
+          safe_name = name.unpack('h*').first
+          generated_attribute_methods::AttrNames.set_name_cache safe_name, name
+
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}
+              read_attribute(AttrNames::ATTR_#{safe_name})
+            end
+            alias_method #{name.inspect}, :__temp__#{safe_name}
+            undef_method :__temp__#{safe_name}
+          STR
+        end
+
+        private
+
+        def cacheable_column?(column)
+          if attribute_types_cached_by_default == ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
+            ! serialized_attributes.include? column.name
+          else
+            attribute_types_cached_by_default.include?(column.type)
+          end
+        end
+      end
+
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after
+      # it has been typecast (for example, "2004-12-12" in a data column is cast
+      # to a date object, like Date.new(2004, 12, 12)).
+      def read_attribute(attr_name)
+        name = attr_name.to_s
+        
+        # If it's a lazily loaded attribute and hasn't been loaded yet, we need to do that now.
+        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
+        
+        # If it's cached, just return it
+        # We use #[] first as a perf optimization for non-nil values. See https://gist.github.com/jonleighton/3552829.
+        @attributes_cache[name] || @attributes_cache.fetch(name) {
+          column = @column_types_override[name] if @column_types_override
+          column ||= self.class.attribute_definitions[name]
+
+          return @attributes.fetch(name) {
+            if name == 'id' && self.class.primary_key != name
+              read_attribute(self.class.primary_key)
+            end
+          } unless column
+
+         value = @attributes.fetch(name) {
+            nil
+          }
+
+          if self.class.cache_attribute?(name)
+            @attributes_cache[name] = column.type_cast(value, self)
+          else
+            column.type_cast value, self
+          end
+        }
+      end
+
+      private
+
+      def attribute(attribute_name)
+        read_attribute(attribute_name)
+      end
+    end
+  end
+end

data/lib/datastax_rails/attribute_methods/typecasting.rb

@@ -10,14 +10,49 @@ module DatastaxRails
         self.attribute_definitions = ActiveSupport::HashWithIndifferentAccess.new
         self.lazy_attributes = []
         self.readonly_attributes = []
-
+      end
+      
+      # This is a hook for use by modules that need to do extra stuff to
+      # attributes when they are initialized. (e.g. attribute
+      # serialization)
+      def initialize_attributes(attributes) #:nodoc:
+        attrs = {}
+          Types::DirtyCollection.ignore_modifications do
+          attributes.each do |k,v|
+            if col = column_for_attribute(k)
+              if col.type == :map && k.to_s != col.name.to_s
+                # See if we have a matching dynamic attribute column
+                self.class.map_columns.each do |mcol|
+                  if k.to_s.starts_with?(mcol.name.to_s)
+                    attrs[mcol.name.to_s] ||= mcol.wrap_collection({}, self)
+                    attrs[mcol.name.to_s][k.to_s] = v
+                  end
+                end
+              else
+                attrs[k.to_s] = col.collection? ? col.wrap_collection(v, self) : v
+              end
+            end
+          end
+        end
+        attrs
       end
 
       module ClassMethods
         # Provide some measure of compatibility with things that expect this from ActiveRecord.
         def columns_hash
           self.attribute_definitions
-        end 
+        end
+        
+        # Gives you all of the map columns (useful for detecting dynamic columns)
+        def map_columns
+          @map_columns ||= self.attribute_definitions.values.select {|c| c.type == :map}
+        end
+        
+        # Returns a hash where the keys are column names and the values are
+        # default values when instantiating the DSR object for this table.
+        def column_defaults
+          @column_defaults ||= Hash[columns.map { |c| [c.name.to_s, c.default] }]
+        end
         
         # We need to ensure that inherited classes get their own attribute definitions.
         def inherited(child)
@@ -42,8 +77,8 @@ module DatastaxRails
         # 
         # @param [Hash] options the options to use in setting up the attribute
         def timestamps(options = {})
-          attribute(:created_at, options.update(:type => :time))
-          attribute(:updated_at, options.update(:type => :time))
+          attribute(:created_at, options.update(:type => :timestamp))
+          attribute(:updated_at, options.update(:type => :timestamp))
         end
         
         # @!method array(name, options = {})
@@ -52,6 +87,8 @@ module DatastaxRails
         #   @macro attr_doc
         # @!method date(name, options = {})
         #   @macro attr_doc
+        # @!method datetime(name, options = {})
+        #   @macro attr_doc
         # @!method float(name, options = {})
         #   @macro attr_doc
         # @!method integer(name, options = {})
@@ -64,11 +101,21 @@ module DatastaxRails
         #   @macro attr_doc
         # @!method time(name, options = {})
         #   @macro attr_doc
+        # @!method timestamp(name, options = {})
+        #   @macro attr_doc
         # @!method time_with_zone(name, options = {})
         #   @macro attr_doc
+        # @!method uuid(name, options = {})
+        #   @macro attr_doc
+        # @!method map(name, options = {})
+        #   @macro attr_doc
+        # @!method list(name, options = {})
+        #   @macro attr_doc
+        # @!method set(name, options = {})
+        #   @macro attr_doc
         
         # The following sets up a bunch of nearly identical attribute methods
-        %w(array boolean date float integer json string text time time_with_zone).each do |type|
+        %w(array boolean date datetime float integer json string text time timestamp time_with_zone uuid map set list).each do |type|
           class_eval <<-EOV, __FILE__, __LINE__ + 1
             def #{type}(name, options = {})                               # def string(name, options = {})
               attribute(name, options.update(:type => :#{type}))             #   attribute(name, options.update(type: :string))
@@ -77,22 +124,6 @@ module DatastaxRails
         end
         
         # @!endgroup
-
-        # 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 typecast 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)
-          else
-            raise NoMethodError, "Unknown attribute #{name.inspect}"
-          end
-        end
       end
     end
   end