activerecord 4.0.5 → 4.0.6.rc1

data/lib/active_record/associations/singular_association.rb

@@ -18,11 +18,11 @@ module ActiveRecord
       end
 
       def create(attributes = {}, &block)
-        create_record(attributes, &block)
+        _create_record(attributes, &block)
       end
 
       def create!(attributes = {}, &block)
-        create_record(attributes, true, &block)
+        _create_record(attributes, true, &block)
       end
 
       def build(attributes = {})
@@ -51,7 +51,7 @@ module ActiveRecord
           replace(record)
         end
 
-        def create_record(attributes, raise_error = false)
+        def _create_record(attributes, raise_error = false)
           record = build_record(attributes)
           yield(record) if block_given?
           saved = record.save

data/lib/active_record/attribute_methods.rb

@@ -161,6 +161,7 @@ module ActiveRecord
           # this is probably horribly slow, but should only happen at most once for a given AR class
           attribute_method.bind(self).call(*args, &block)
         else
+          return super unless respond_to_missing?(method, true)
           send(method, *args, &block)
         end
       else

data/lib/active_record/attribute_methods/dirty.rb

@@ -70,11 +70,11 @@ module ActiveRecord
         super(attr, value)
       end
 
-      def update_record(*)
+      def _update_record(*)
         partial_writes? ? super(keys_for_partial_write) : super
       end
 
-      def create_record(*)
+      def _create_record(*)
         partial_writes? ? super(keys_for_partial_write) : super
       end
 

data/lib/active_record/attribute_methods/serialization.rb

@@ -27,7 +27,8 @@ module ActiveRecord
         # ==== Parameters
         #
         # * +attr_name+ - The field name that should be serialized.
-        # * +class_name+ - Optional, class name that the object type should be equal to.
+        # * +class_name_or_coder+ - Optional, a coder object, which responds to `.load` / `.dump`
+        #   or a class name that the object type should be equal to.
         #
         # ==== Example
         #
@@ -35,13 +36,23 @@ module ActiveRecord
         #   class User < ActiveRecord::Base
         #     serialize :preferences
         #   end
-        def serialize(attr_name, class_name = Object)
+        #
+        #   # Serialize preferences using JSON as coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, JSON
+        #   end
+        #
+        #   # Serialize preferences as Hash using YAML coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, Hash
+        #   end
+        def serialize(attr_name, class_name_or_coder = Object)
           include Behavior
 
-          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
-                    class_name
+          coder = if [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+                    class_name_or_coder
                   else
-                    Coders::YAMLColumn.new(class_name)
+                    Coders::YAMLColumn.new(class_name_or_coder)
                   end
 
           # merge new serialized attribute and create new hash to ensure that each class in inheritance hierarchy

data/lib/active_record/base.rb

@@ -305,8 +305,8 @@ module ActiveRecord #:nodoc:
     include Locking::Optimistic
     include Locking::Pessimistic
     include AttributeMethods
-    include Callbacks
     include Timestamp
+    include Callbacks
     include Associations
     include ActiveModel::SecurePassword
     include AutosaveAssociation

data/lib/active_record/callbacks.rb

@@ -302,11 +302,11 @@ module ActiveRecord
       run_callbacks(:save) { super }
     end
 
-    def create_record #:nodoc:
+    def _create_record #:nodoc:
       run_callbacks(:create) { super }
     end
 
-    def update_record(*) #:nodoc:
+    def _update_record(*) #:nodoc:
       run_callbacks(:update) { super }
     end
   end

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -21,14 +21,7 @@ module ActiveRecord
       # Returns an array of record hashes with the column names as keys and
       # column values as values.
       def select_all(arel, name = nil, binds = [])
-        if arel.is_a?(Relation)
-          relation = arel
-          arel = relation.arel
-          if !binds || binds.empty?
-            binds = relation.bind_values
-          end
-        end
-
+        arel, binds = binds_from_relation arel, binds
         select(to_sql(arel, binds), name, binds)
       end
 
@@ -49,10 +42,7 @@ module ActiveRecord
       # Returns an array of the values of the first column in a select:
       #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
       def select_values(arel, name = nil)
-        binds = []
-        if arel.is_a?(Relation)
-          arel, binds = arel.arel, arel.bind_values
-        end
+        arel, binds = binds_from_relation arel, []
         select_rows(to_sql(arel, binds), name, binds).map(&:first)
       end
 
@@ -396,6 +386,13 @@ module ActiveRecord
           row = result.rows.first
           row && row.first
         end
+
+        def binds_from_relation(relation, binds)
+          if relation.is_a?(Relation) && binds.blank?
+            relation, binds = relation.arel, relation.bind_values
+          end
+          [relation, binds]
+        end
     end
   end
 end

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -57,6 +57,7 @@ module ActiveRecord
 
       def select_all(arel, name = nil, binds = [])
         if @query_cache_enabled && !locked?(arel)
+          arel, binds = binds_from_relation arel, binds
           sql = to_sql(arel, binds)
           cache_sql(sql, binds) { super(sql, name, binds) }
         else

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -15,7 +15,7 @@ module ActiveRecord
     # are typically created by methods in TableDefinition, and added to the
     # +columns+ attribute of said TableDefinition object, in order to be used
     # for generating a number of table creation or table changing SQL statements.
-    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :primary_key) #:nodoc:
+    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :primary_key, :sql_type) #:nodoc:
       def string_to_binary(value)
         value
       end

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -869,6 +869,12 @@ module ActiveRecord
           end
         end
 
+        def quote_value(value, column)
+          column.sql_type ||= type_to_sql(column.type, column.limit, column.precision, column.scale)
+
+          quote(value, column)
+        end
+
       private
       def create_table_definition(name, temporary, options)
         TableDefinition.new native_database_types, name, temporary, options

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -743,22 +743,22 @@ module ActiveRecord
       end
 
       def configure_connection
-        variables = @config[:variables] || {}
+        variables = @config.fetch(:variables, {}).stringify_keys
 
         # By default, MySQL 'where id is null' selects the last inserted id.
         # Turn this off. http://dev.rubyonrails.org/ticket/6778
-        variables[:sql_auto_is_null] = 0
+        variables['sql_auto_is_null'] = 0
 
         # Increase timeout so the server doesn't disconnect us.
         wait_timeout = @config[:wait_timeout]
         wait_timeout = 2147483 unless wait_timeout.is_a?(Fixnum)
-        variables[:wait_timeout] = self.class.type_cast_config_to_integer(wait_timeout)
+        variables['wait_timeout'] = self.class.type_cast_config_to_integer(wait_timeout)
 
         # Make MySQL reject illegal values rather than truncating or blanking them, see
         # http://dev.mysql.com/doc/refman/5.0/en/server-sql-mode.html#sqlmode_strict_all_tables
         # If the user has provided another value for sql_mode, don't replace it.
-        if strict_mode? && !variables.has_key?(:sql_mode)
-          variables[:sql_mode] = 'STRICT_ALL_TABLES'
+        if strict_mode? && !variables.has_key?('sql_mode')
+          variables['sql_mode'] = 'STRICT_ALL_TABLES'
         end
 
         # NAMES does not have an equals sign, see

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -143,10 +143,7 @@ module ActiveRecord
             fields.each_with_index do |fname, i|
               ftype = result.ftype i
               fmod  = result.fmod i
-              types[fname] = OID::TYPE_MAP.fetch(ftype, fmod) { |oid, mod|
-                warn "unknown OID: #{fname}(#{oid}) (#{sql})"
-                OID::Identity.new
-              }
+              types[fname] = get_oid_type(ftype, fmod, fname)
             end
 
             ret = ActiveRecord::Result.new(fields, result.values, types)

data/lib/active_record/connection_adapters/postgresql/quoting.rb

@@ -167,6 +167,15 @@ module ActiveRecord
           end
           result
         end
+
+        # Does not quote function default values for UUID columns
+        def quote_default_value(value, column) #:nodoc:
+          if column.type == :uuid && value =~ /\(\)/
+            value
+          else
+            quote(value, column)
+          end
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -185,13 +185,15 @@ module ActiveRecord
         def columns(table_name)
           # Limit, precision, and scale are all handled by the superclass.
           column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod|
-            oid = OID::TYPE_MAP.fetch(oid.to_i, fmod.to_i) {
-              OID::Identity.new
-            }
+            oid = get_oid_type(oid.to_i, fmod.to_i, column_name)
             PostgreSQLColumn.new(column_name, default, oid, type, notnull == 'f')
           end
         end
 
+        def column_for(table_name, column_name) #:nodoc:
+          columns(table_name).detect { |c| c.name == column_name.to_s }
+        end
+
         # Returns the current database name.
         def current_database
           query('select current_database()', 'SCHEMA')[0][0]
@@ -408,13 +410,16 @@ module ActiveRecord
         # Changes the default value of a table column.
         def change_column_default(table_name, column_name, default)
           clear_cache!
-          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT #{quote(default)}"
+          column = column_for(table_name, column_name)
+
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT #{quote_default_value(default, column)}" if column
         end
 
         def change_column_null(table_name, column_name, null, default = nil)
           clear_cache!
           unless null || default.nil?
-            execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+            column = column_for(table_name, column_name)
+            execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_value(default, column)} WHERE #{quote_column_name(column_name)} IS NULL") if column
           end
           execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL")
         end

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -749,6 +749,13 @@ module ActiveRecord
 
       private
 
+        def get_oid_type(oid, fmod, column_name)
+          OID::TYPE_MAP.fetch(oid, fmod) {
+            warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+            OID::TYPE_MAP[oid] = OID::Identity.new
+          }
+        end
+
         def reload_type_map
           OID::TYPE_MAP.clear
           initialize_type_map

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -297,9 +297,12 @@ module ActiveRecord
           # Don't cache statements if they are not prepared
           if without_prepared_statement?(binds)
             stmt    = @connection.prepare(sql)
-            cols    = stmt.columns
-            records = stmt.to_a
-            stmt.close
+            begin
+              cols    = stmt.columns
+              records = stmt.to_a
+            ensure
+              stmt.close
+            end
             stmt = records
           else
             cache = @statements[sql] ||= {

data/lib/active_record/connection_handling.rb

@@ -15,14 +15,14 @@ module ActiveRecord
     # Example for SQLite database:
     #
     #   ActiveRecord::Base.establish_connection(
-    #     adapter:  "sqlite",
+    #     adapter:  "sqlite3",
     #     database: "path/to/dbfile"
     #   )
     #
     # Also accepts keys as strings (for parsing from YAML for example):
     #
     #   ActiveRecord::Base.establish_connection(
-    #     "adapter"  => "sqlite",
+    #     "adapter"  => "sqlite3",
     #     "database" => "path/to/dbfile"
     #   )
     #

data/lib/active_record/core.rb

@@ -257,6 +257,7 @@ module ActiveRecord
       @attributes_cache  = {}
 
       @new_record  = true
+      @destroyed   = false
 
       ensure_proper_type
       super

data/lib/active_record/locking/optimistic.rb

@@ -66,7 +66,7 @@ module ActiveRecord
           send(lock_col + '=', previous_lock_value + 1)
         end
 
-        def update_record(attribute_names = @attributes.keys) #:nodoc:
+        def _update_record(attribute_names = @attributes.keys) #:nodoc:
           return super unless locking_enabled?
           return 0 if attribute_names.empty?
 

data/lib/active_record/migration.rb

@@ -620,7 +620,7 @@ module ActiveRecord
 
       say_with_time "#{method}(#{arg_list})" do
         unless @connection.respond_to? :revert
-          unless arguments.empty? || method == :execute
+          unless arguments.empty? || [:execute, :enable_extension, :disable_extension].include?(method)
             arguments[0] = Migrator.proper_table_name(arguments.first)
             arguments[1] = Migrator.proper_table_name(arguments.second) if method == :rename_table
           end

data/lib/active_record/null_relation.rb

@@ -43,15 +43,21 @@ module ActiveRecord
     end
 
     def count(*)
-      0
+      calculate :count, nil
     end
 
     def sum(*)
       0
     end
 
-    def calculate(_operation, _column_name, _options = {})
-      nil
+    def calculate(operation, _column_name, _options = {})
+      # TODO: Remove _options argument as soon we remove support to
+      # activerecord-deprecated_finders.
+      if operation == :count
+        group_values.any? ? Hash.new : 0
+      else
+        nil
+      end
     end
 
     def exists?(_id = false)

data/lib/active_record/persistence.rb

@@ -37,7 +37,7 @@ module ActiveRecord
       end
 
       # Given an attributes hash, +instantiate+ returns a new instance of
-      # the appropriate class.
+      # the appropriate class. Accepts only keys as strings.
       #
       # For example, +Post.all+ may return Comments, Messages, and Emails
       # by storing the record's subclass in a +type+ attribute. By calling
@@ -46,10 +46,10 @@ module ActiveRecord
       #
       # See +ActiveRecord::Inheritance#discriminate_class_for_record+ to see
       # how this "single-table" inheritance mapping is implemented.
-      def instantiate(record, column_types = {})
-        klass = discriminate_class_for_record(record)
+      def instantiate(attributes, column_types = {})
+        klass = discriminate_class_for_record(attributes)
         column_types = klass.decorate_columns(column_types.dup)
-        klass.allocate.init_with('attributes' => record, 'column_types' => column_types)
+        klass.allocate.init_with('attributes' => attributes, 'column_types' => column_types)
       end
 
       private
@@ -448,6 +448,8 @@ module ActiveRecord
         @changed_attributes.except!(*changes.keys)
         primary_key = self.class.primary_key
         self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
+      else
+        true
       end
     end
 
@@ -475,13 +477,13 @@ module ActiveRecord
 
     def create_or_update
       raise ReadOnlyRecord if readonly?
-      result = new_record? ? create_record : update_record
+      result = new_record? ? _create_record : _update_record
       result != false
     end
 
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
-    def update_record(attribute_names = @attributes.keys)
+    def _update_record(attribute_names = @attributes.keys)
       attributes_with_values = arel_attributes_with_values_for_update(attribute_names)
       if attributes_with_values.empty?
         0
@@ -504,7 +506,7 @@ module ActiveRecord
 
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
-    def create_record(attribute_names = @attributes.keys)
+    def _create_record(attribute_names = @attributes.keys)
       attributes_values = arel_attributes_with_values_for_create(attribute_names)
 
       new_id = self.class.unscoped.insert attributes_values

data/lib/active_record/railties/databases.rake

@@ -287,7 +287,8 @@ db_namespace = namespace :db do
       current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
 
-      if ActiveRecord::Base.connection.supports_migrations?
+      if ActiveRecord::Base.connection.supports_migrations? &&
+          ActiveRecord::SchemaMigration.table_exists?
         File.open(filename, "a") do |f|
           f.puts ActiveRecord::Base.connection.dump_schema_information
         end