activerecord 5.1.4 → 5.1.5.rc1

data/lib/active_record/connection_adapters/column.rb

@@ -13,7 +13,7 @@ module ActiveRecord
       # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
       # +sql_type_metadata+ is various information about the type of the column
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil)
+      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil, **)
         @name = name.freeze
         @table_name = table_name
         @sql_type_metadata = sql_type_metadata

data/lib/active_record/connection_adapters/mysql/schema_dumper.rb

@@ -5,6 +5,7 @@ module ActiveRecord
         def prepare_column_options(column)
           spec = super
           spec[:unsigned] = "true" if column.unsigned?
+          spec[:auto_increment] = "true" if column.auto_increment?
 
           if supports_virtual_columns? && column.virtual?
             spec[:as] = extract_expression_for_virtual_column(column)
@@ -15,6 +16,12 @@ module ActiveRecord
           spec
         end
 
+        def column_spec_for_primary_key(column)
+          spec = super
+          spec.delete(:auto_increment) if column.type == :integer && column.auto_increment?
+          spec
+        end
+
         def migration_keys
           super + [:unsigned]
         end

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

@@ -5,11 +5,38 @@ module ActiveRecord
       delegate :array, :oid, :fmod, to: :sql_type_metadata
       alias :array? :array
 
+      def initialize(*, max_identifier_length: 63, **)
+        super
+        @max_identifier_length = max_identifier_length
+      end
+
       def serial?
         return unless default_function
 
-        %r{\Anextval\('"?#{table_name}_#{name}_seq"?'::regclass\)\z} === default_function
+        if %r{\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z} =~ default_function
+          sequence_name_from_parts(table_name, name, suffix) == sequence_name
+        end
       end
+
+      protected
+        attr_reader :max_identifier_length
+
+      private
+        def sequence_name_from_parts(table_name, column_name, suffix)
+          over_length = [table_name, column_name, suffix].map(&:length).sum + 2 - max_identifier_length
+
+          if over_length > 0
+            column_name_length = [(max_identifier_length - suffix.length - 2) / 2, column_name.length].min
+            over_length -= column_name.length - column_name_length
+            column_name = column_name[0, column_name_length - [over_length, 0].min]
+          end
+
+          if over_length > 0
+            table_name = table_name[0, table_name.length - over_length]
+          end
+
+          "#{table_name}_#{column_name}_#{suffix}"
+        end
     end
   end
 end

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

@@ -62,7 +62,7 @@ module ActiveRecord
         def quote_default_expression(value, column) # :nodoc:
           if value.is_a?(Proc)
             value.call
-          elsif column.type == :uuid && /\(\)/.match?(value)
+          elsif column.type == :uuid && value.is_a?(String) && /\(\)/.match?(value)
             value # Does not quote function default values for UUID columns
           elsif column.respond_to?(:array?)
             value = type_cast_from_column(column, value)

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

@@ -159,7 +159,8 @@ module ActiveRecord
             table_name,
             default_function,
             collation,
-            comment: comment.presence
+            comment: comment.presence,
+            max_identifier_length: max_identifier_length
           )
         end
 

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,5 +1,5 @@
 # Make sure we're using pg high enough for type casts and Ruby 2.2+ compatibility
-gem "pg", "~> 0.18"
+gem "pg", ">= 0.18", "< 2.0"
 require "pg"
 
 require "active_record/connection_adapters/abstract_adapter"
@@ -198,6 +198,7 @@ module ActiveRecord
 
           def dealloc(key)
             @connection.query "DEALLOCATE #{key}" if connection_active?
+          rescue PG::Error
           end
 
           def connection_active?
@@ -364,10 +365,11 @@ module ActiveRecord
       end
 
       # Returns the configured supported identifier length supported by PostgreSQL
-      def table_alias_length
+      def max_identifier_length
         @max_identifier_length ||= query_value("SHOW max_identifier_length", "SCHEMA").to_i
       end
-      alias index_name_length table_alias_length
+      alias table_alias_length max_identifier_length
+      alias index_name_length max_identifier_length
 
       # Set the authorized user for this session
       def session_auth=(user)

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -340,7 +340,7 @@ module ActiveRecord
       end
 
       def add_column(table_name, column_name, type, options = {}) #:nodoc:
-        if valid_alter_table_type?(type)
+        if valid_alter_table_type?(type) && !options[:primary_key]
           super(table_name, column_name, type, options)
         else
           alter_table(table_name) do |definition|
@@ -440,18 +440,21 @@ module ActiveRecord
           options[:id] = false
           create_table(to, options) do |definition|
             @definition = definition
-            @definition.primary_key(from_primary_key) if from_primary_key.present?
+            if from_primary_key.is_a?(Array)
+              @definition.primary_keys from_primary_key
+            end
             columns(from).each do |column|
               column_name = options[:rename] ?
                 (options[:rename][column.name] ||
                  options[:rename][column.name.to_sym] ||
                  column.name) : column.name
-              next if column_name == from_primary_key
 
               @definition.column(column_name, column.type,
                 limit: column.limit, default: column.default,
                 precision: column.precision, scale: column.scale,
-                null: column.null, collation: column.collation)
+                null: column.null, collation: column.collation,
+                primary_key: column_name == from_primary_key
+              )
             end
             yield @definition if block_given?
           end
@@ -464,6 +467,9 @@ module ActiveRecord
         def copy_table_indexes(from, to, rename = {})
           indexes(from).each do |index|
             name = index.name
+            # indexes sqlite creates for internal use start with `sqlite_` and
+            # don't need to be copied
+            next if name.starts_with?("sqlite_")
             if to == "a#{from}"
               name = "t#{name}"
             elsif from == "a#{to}"
@@ -479,6 +485,7 @@ module ActiveRecord
               # index name can't be the same
               opts = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
               opts[:unique] = true if index.unique
+              opts[:where] = index.where if index.where
               add_index(to, columns, opts)
             end
           end

data/lib/active_record/gem_version.rb

@@ -7,8 +7,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 5
     MINOR = 1
-    TINY  = 4
-    PRE   = nil
+    TINY  = 5
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/locking/pessimistic.rb

@@ -60,7 +60,7 @@ module ActiveRecord
       # the locked record.
       def lock!(lock = true)
         if persisted?
-          if changed?
+          if has_changes_to_save?
             ActiveSupport::Deprecation.warn(<<-MSG.squish)
               Locking a record with unpersisted changes is deprecated and will raise an
               exception in Rails 5.2. Use `save` to persist the changes, or `reload` to

data/lib/active_record/log_subscriber.rb

@@ -29,7 +29,7 @@ module ActiveRecord
       binds = nil
 
       unless (payload[:binds] || []).empty?
-        casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
+        casted_params = type_casted_binds(payload[:type_casted_binds])
         binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
           render_bind(attr, value)
         }.inspect
@@ -42,9 +42,8 @@ module ActiveRecord
     end
 
     private
-
-      def type_casted_binds(binds, casted_binds)
-        casted_binds || ActiveRecord::Base.connection.type_casted_binds(binds)
+      def type_casted_binds(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
       end
 
       def render_bind(attr, value)

data/lib/active_record/migration/compatibility.rb

@@ -42,11 +42,8 @@ module ActiveRecord
           end
 
           if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
+            super do |t|
+              yield compatible_table_definition(t)
             end
           else
             super
@@ -55,11 +52,20 @@ module ActiveRecord
 
         def change_table(table_name, options = {})
           if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
+            super do |t|
+              yield compatible_table_definition(t)
+            end
+          else
+            super
+          end
+        end
+
+        def create_join_table(table_1, table_2, column_options: {}, **options)
+          column_options.reverse_merge!(type: :integer)
+
+          if block_given?
+            super do |t|
+              yield compatible_table_definition(t)
             end
           else
             super
@@ -70,6 +76,14 @@ module ActiveRecord
           super(table_name, ref_name, type: :integer, **options)
         end
         alias :add_belongs_to :add_reference
+
+        private
+          def compatible_table_definition(t)
+            class << t
+              prepend TableDefinition
+            end
+            t
+          end
       end
 
       class V4_2 < V5_0
@@ -88,11 +102,8 @@ module ActiveRecord
 
         def create_table(table_name, options = {})
           if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
+            super do |t|
+              yield compatible_table_definition(t)
             end
           else
             super
@@ -101,11 +112,8 @@ module ActiveRecord
 
         def change_table(table_name, options = {})
           if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
+            super do |t|
+              yield compatible_table_definition(t)
             end
           else
             super
@@ -141,6 +149,12 @@ module ActiveRecord
         end
 
         private
+          def compatible_table_definition(t)
+            class << t
+              prepend TableDefinition
+            end
+            super
+          end
 
           def index_name_for_remove(table_name, options = {})
             index_name = index_name(table_name, options)

data/lib/active_record/model_schema.rb

@@ -84,19 +84,6 @@ module ActiveRecord
     #
     # Sets the name of the internal metadata table.
 
-    ##
-    # :singleton-method: protected_environments
-    # :call-seq: protected_environments
-    #
-    # The array of names of environments where destructive actions should be prohibited. By default,
-    # the value is <tt>["production"]</tt>.
-
-    ##
-    # :singleton-method: protected_environments=
-    # :call-seq: protected_environments=(environments)
-    #
-    # Sets an array of names of environments where destructive actions should be prohibited.
-
     ##
     # :singleton-method: pluralize_table_names
     # :call-seq: pluralize_table_names
@@ -113,20 +100,6 @@ module ActiveRecord
     # If true, the default table name for a Product class will be "products". If false, it would just be "product".
     # See table_name for the full rules on table/class naming. This is true, by default.
 
-    ##
-    # :singleton-method: ignored_columns
-    # :call-seq: ignored_columns
-    #
-    # The list of columns names the model should ignore. Ignored columns won't have attribute
-    # accessors defined, and won't be referenced in SQL queries.
-
-    ##
-    # :singleton-method: ignored_columns=
-    # :call-seq: ignored_columns=(columns)
-    #
-    # Sets the columns names the model should ignore. Ignored columns won't have attribute
-    # accessors defined, and won't be referenced in SQL queries.
-
     included do
       mattr_accessor :primary_key_prefix_type, instance_writer: false
 
@@ -142,16 +115,12 @@ module ActiveRecord
       class_attribute :internal_metadata_table_name, instance_accessor: false
       self.internal_metadata_table_name = "ar_internal_metadata"
 
-      class_attribute :protected_environments, instance_accessor: false
-      self.protected_environments = ["production"]
-
       class_attribute :pluralize_table_names, instance_writer: false
       self.pluralize_table_names = true
 
-      class_attribute :ignored_columns, instance_accessor: false
-      self.ignored_columns = [].freeze
-
+      self.protected_environments = ["production"]
       self.inheritance_column = "type"
+      self.ignored_columns = [].freeze
 
       delegate :type_for_attribute, to: :class
 
@@ -263,6 +232,21 @@ module ActiveRecord
         (parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
       end
 
+      # The array of names of environments where destructive actions should be prohibited. By default,
+      # the value is <tt>["production"]</tt>.
+      def protected_environments
+        if defined?(@protected_environments)
+          @protected_environments
+        else
+          superclass.protected_environments
+        end
+      end
+
+      # Sets an array of names of environments where destructive actions should be prohibited.
+      def protected_environments=(environments)
+        @protected_environments = environments.map(&:to_s)
+      end
+
       # Defines the name of the table column which will store the class name on single-table
       # inheritance situations.
       #
@@ -282,6 +266,22 @@ module ActiveRecord
         @explicit_inheritance_column = true
       end
 
+      # The list of columns names the model should ignore. Ignored columns won't have attribute
+      # accessors defined, and won't be referenced in SQL queries.
+      def ignored_columns
+        if defined?(@ignored_columns)
+          @ignored_columns
+        else
+          superclass.ignored_columns
+        end
+      end
+
+      # Sets the columns names the model should ignore. Ignored columns won't have attribute
+      # accessors defined, and won't be referenced in SQL queries.
+      def ignored_columns=(columns)
+        @ignored_columns = columns.map(&:to_s)
+      end
+
       def sequence_name
         if base_class == self
           @sequence_name ||= reset_sequence_name

data/lib/active_record/persistence.rb

@@ -267,11 +267,7 @@ module ActiveRecord
       verify_readonly_attribute(name)
       public_send("#{name}=", value)
 
-      if has_changes_to_save?
-        save(validate: false)
-      else
-        true
-      end
+      save(validate: false)
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the

data/lib/active_record/query_cache.rb

@@ -5,20 +5,20 @@ module ActiveRecord
       # Enable the query cache within the block if Active Record is configured.
       # If it's not, it will execute the given block.
       def cache(&block)
-        if connected?
-          connection.cache(&block)
-        else
+        if configurations.empty?
           yield
+        else
+          connection.cache(&block)
         end
       end
 
       # Disable the query cache within the block if Active Record is configured.
       # If it's not, it will execute the given block.
       def uncached(&block)
-        if connected?
-          connection.uncached(&block)
-        else
+        if configurations.empty?
           yield
+        else
+          connection.uncached(&block)
         end
       end
     end