1 files changed, 64 insertions, 54 deletions
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index 964c4123ef..846ac03d82 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -58,78 +58,88 @@ module ActiveRecord
         end
 
         protected
-          # We want to generate the methods via module_eval rather than define_method,
-          # because define_method is slower on dispatch and uses more memory (because it
-          # creates a closure).
-          #
-          # 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.
-          def define_method_attribute(attr_name)
-            cast_code = attribute_cast_code(attr_name)
-
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def __temp__
-                #{internal_attribute_access_code(attr_name, cast_code)}
-              end
-              alias_method '#{attr_name}', :__temp__
-              undef_method :__temp__
-            STR
-
-            generated_external_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def __temp__(v, attributes, attributes_cache, attr_name)
-                #{external_attribute_access_code(attr_name, cast_code)}
-              end
-              alias_method '#{attr_name}', :__temp__
-              undef_method :__temp__
-            STR
-          end
-
-        private
-          def cacheable_column?(column)
-            attribute_types_cached_by_default.include?(column.type)
-          end
-
-          def internal_attribute_access_code(attr_name, cast_code)
-            access_code = "(v=@attributes[attr_name]) && #{cast_code}"
-
-            unless attr_name == primary_key
-              access_code.insert(0, "missing_attribute(attr_name, caller) unless @attributes.has_key?(attr_name); ")
+        # We want to generate the methods via module_eval rather than define_method,
+        # because define_method is slower on dispatch and uses more memory (because it
+        # creates a closure).
+        #
+        # 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.
+        def define_method_attribute(attr_name)
+          cast_code = attribute_cast_code(attr_name)
+
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__
+              #{internal_attribute_access_code(attr_name, cast_code)}
             end
+            alias_method '#{attr_name}', :__temp__
+            undef_method :__temp__
+          STR
 
-            if cache_attribute?(attr_name)
-              access_code = "@attributes_cache[attr_name] ||= (#{access_code})"
+          generated_external_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__(v, attributes, attributes_cache, attr_name)
+              #{external_attribute_access_code(attr_name, cast_code)}
             end
+            alias_method '#{attr_name}', :__temp__
+            undef_method :__temp__
+          STR
+        end
 
-            "attr_name = '#{attr_name}'; #{access_code}"
+        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
 
-          def external_attribute_access_code(attr_name, cast_code)
-            access_code = "v && #{cast_code}"
+        def internal_attribute_access_code(attr_name, cast_code)
+          "read_attribute('#{attr_name}') { |n| missing_attribute(n, caller) }"
+        end
 
-            if cache_attribute?(attr_name)
-              access_code = "attributes_cache[attr_name] ||= (#{access_code})"
-            end
+        def external_attribute_access_code(attr_name, cast_code)
+          access_code = "v && #{cast_code}"
 
-            access_code
+          if cache_attribute?(attr_name)
+            access_code = "attributes_cache[attr_name] ||= (#{access_code})"
           end
 
-          def attribute_cast_code(attr_name)
-            columns_hash[attr_name].type_cast_code('v')
-          end
+          access_code
+        end
+
+        def attribute_cast_code(attr_name)
+          columns_hash[attr_name].type_cast_code('v')
+        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)
-        self.class.type_cast_attribute(attr_name, @attributes, @attributes_cache)
+        # If it's cached, just return it
+        @attributes_cache.fetch(attr_name) { |name|
+          column = @columns_hash.fetch(name) {
+            return self.class.type_cast_attribute(name, @attributes, @attributes_cache)
+          }
+
+          value = @attributes.fetch(name) {
+            return block_given? ? yield(name) : nil
+          }
+
+          if self.class.cache_attribute?(name)
+            @attributes_cache[name] = column.type_cast(value)
+          else
+            column.type_cast value
+          end
+        }
       end
 
       private
-        def attribute(attribute_name)
-          read_attribute(attribute_name)
-        end
+
+      def attribute(attribute_name)
+        read_attribute(attribute_name)
+      end
     end
   end
 end