activerecord 4.2.0 → 4.2.11

data/lib/active_record/connection_adapters/postgresql/oid/date_time.rb

@@ -5,6 +5,15 @@ module ActiveRecord
         class DateTime < Type::DateTime # :nodoc:
           include Infinity
 
+          def type_cast_for_database(value)
+            if has_precision? && value.acts_like?(:time) && value.year <= 0
+              bce_year = format("%04d", -value.year + 1)
+              super.sub(/^-?\d+/, bce_year) + " BC"
+            else
+              super
+            end
+          end
+
           def cast_value(value)
             if value.is_a?(::String)
               case value

data/lib/active_record/connection_adapters/postgresql/oid/enum.rb

@@ -7,7 +7,9 @@ module ActiveRecord
             :enum
           end
 
-          def type_cast(value)
+          private
+
+          def cast_value(value)
             value.to_s
           end
         end

data/lib/active_record/connection_adapters/postgresql/oid/json.rb

@@ -11,7 +11,7 @@ module ActiveRecord
 
           def type_cast_from_database(value)
             if value.is_a?(::String)
-              ::ActiveSupport::JSON.decode(value)
+              ::ActiveSupport::JSON.decode(value) rescue nil
             else
               super
             end

data/lib/active_record/connection_adapters/postgresql/oid/specialized_string.rb

@@ -8,6 +8,10 @@ module ActiveRecord
           def initialize(type)
             @type = type
           end
+
+          def text?
+            false
+          end
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb

@@ -15,11 +15,11 @@ module ActiveRecord
           def run(records)
             nodes = records.reject { |row| @store.key? row['oid'].to_i }
             mapped, nodes = nodes.partition { |row| @store.key? row['typname'] }
-            ranges, nodes = nodes.partition { |row| row['typtype'] == 'r' }
-            enums, nodes = nodes.partition { |row| row['typtype'] == 'e' }
-            domains, nodes = nodes.partition { |row| row['typtype'] == 'd' }
-            arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }
-            composites, nodes = nodes.partition { |row| row['typelem'] != '0' }
+            ranges, nodes = nodes.partition { |row| row['typtype'] == 'r'.freeze }
+            enums, nodes = nodes.partition { |row| row['typtype'] == 'e'.freeze }
+            domains, nodes = nodes.partition { |row| row['typtype'] == 'd'.freeze }
+            arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in'.freeze }
+            composites, nodes = nodes.partition { |row| row['typelem'].to_i != 0 }
 
             mapped.each     { |row| register_mapped_type(row)    }
             enums.each      { |row| register_enum_type(row)      }
@@ -29,6 +29,18 @@ module ActiveRecord
             composites.each { |row| register_composite_type(row) }
           end
 
+          def query_conditions_for_initial_load(type_map)
+            known_type_names = type_map.keys.map { |n| "'#{n}'" }
+            known_type_types = %w('r' 'e' 'd')
+            <<-SQL % [known_type_names.join(", "), known_type_types.join(", ")]
+              WHERE
+                t.typname IN (%s)
+                OR t.typtype IN (%s)
+                OR t.typinput = 'array_in(cstring,oid,integer)'::regprocedure
+                OR t.typelem != 0
+            SQL
+          end
+
           private
           def register_mapped_type(row)
             alias_type row['oid'], row['typname']

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

@@ -76,15 +76,15 @@ module ActiveRecord
           column(name, :point, options)
         end
 
-        def bit(name, options)
+        def bit(name, options = {})
           column(name, :bit, options)
         end
 
-        def bit_varying(name, options)
+        def bit_varying(name, options = {})
           column(name, :bit_varying, options)
         end
 
-        def money(name, options)
+        def money(name, options = {})
           column(name, :money, options)
         end
       end

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

@@ -86,7 +86,7 @@ module ActiveRecord
           execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
         end
 
-        # Returns the list of all tables in the schema search path or a specified schema.
+        # Returns the list of all tables in the schema search path.
         def tables(name = nil)
           query(<<-SQL, 'SCHEMA').map { |row| row[0] }
             SELECT tablename
@@ -95,6 +95,16 @@ module ActiveRecord
           SQL
         end
 
+        def data_sources # :nodoc
+          select_values(<<-SQL, 'SCHEMA')
+            SELECT c.relname
+            FROM pg_class c
+            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind IN ('r', 'v','m') -- (r)elation/table, (v)iew, (m)aterialized view
+            AND n.nspname = ANY (current_schemas(false))
+          SQL
+        end
+
         # Returns true if table exists.
         # If the schema is not specified as part of +name+ then it will only find tables within
         # the current schema search path (regardless of permissions to access tables in other schemas)
@@ -111,6 +121,7 @@ module ActiveRecord
               AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
           SQL
         end
+        alias data_source_exists? table_exists?
 
         def drop_table(table_name, options = {})
           execute "DROP TABLE #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
@@ -386,15 +397,15 @@ module ActiveRecord
 
         # Returns just a table's primary key
         def primary_key(table)
-          row = exec_query(<<-end_sql, 'SCHEMA').rows.first
+          pks = exec_query(<<-end_sql, 'SCHEMA').rows
             SELECT attr.attname
             FROM pg_attribute attr
-            INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = cons.conkey[1]
+            INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = any(cons.conkey)
             WHERE cons.contype = 'p'
               AND cons.conrelid = '#{quote_table_name(table)}'::regclass
           end_sql
-
-          row && row.first
+          return nil unless pks.count == 1
+          pks[0][0]
         end
 
         # Renames a table.
@@ -418,9 +429,7 @@ module ActiveRecord
           rename_table_indexes(table_name, new_name)
         end
 
-        # Adds a new column to the named table.
-        # See TableDefinition#column for details of the options you can use.
-        def add_column(table_name, column_name, type, options = {})
+        def add_column(table_name, column_name, type, options = {}) #:nodoc:
           clear_cache!
           super
         end
@@ -468,7 +477,7 @@ module ActiveRecord
         end
 
         # Renames a column in a table.
-        def rename_column(table_name, column_name, new_column_name)
+        def rename_column(table_name, column_name, new_column_name) #:nodoc:
           clear_cache!
           execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
           rename_column_indexes(table_name, column_name, new_column_name)
@@ -484,9 +493,8 @@ module ActiveRecord
         end
 
         def rename_index(table_name, old_name, new_name)
-          if new_name.length > allowed_index_name_length
-            raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{allowed_index_name_length} characters"
-          end
+          validate_index_length!(table_name, new_name)
+
           execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
         end
 
@@ -555,7 +563,7 @@ module ActiveRecord
               when 1, 2; 'smallint'
               when 3, 4; 'integer'
               when 5..8; 'bigint'
-              else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
+              else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead.")
             end
           when 'datetime'
             return super unless precision

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -64,7 +64,7 @@ module ActiveRecord
     #   <tt>SET client_min_messages TO <min_messages></tt> call on the connection.
     # * <tt>:variables</tt> - An optional hash of additional parameters that
     #   will be used in <tt>SET SESSION key = val</tt> calls on the connection.
-    # * <tt>:insert_returning</tt> - An optional boolean to control the use or <tt>RETURNING</tt> for <tt>INSERT</tt> statements
+    # * <tt>:insert_returning</tt> - An optional boolean to control the use of <tt>RETURNING</tt> for <tt>INSERT</tt> statements
     #   defaults to true.
     #
     # Any further options are used as connection parameters to libpq. See
@@ -308,12 +308,8 @@ module ActiveRecord
         true
       end
 
-      # Enable standard-conforming strings if available.
       def set_standard_conforming_strings
-        old, self.client_min_messages = client_min_messages, 'panic'
-        execute('SET standard_conforming_strings = on', 'SCHEMA') rescue nil
-      ensure
-        self.client_min_messages = old
+        execute('SET standard_conforming_strings = on', 'SCHEMA')
       end
 
       def supports_ddl_transactions?
@@ -445,8 +441,8 @@ module ActiveRecord
 
         def initialize_type_map(m) # :nodoc:
           register_class_with_limit m, 'int2', OID::Integer
-          m.alias_type 'int4', 'int2'
-          m.alias_type 'int8', 'int2'
+          register_class_with_limit m, 'int4', OID::Integer
+          register_class_with_limit m, 'int8', OID::Integer
           m.alias_type 'oid', 'int2'
           m.register_type 'float4', OID::Float.new
           m.alias_type 'float8', 'float4'
@@ -556,6 +552,8 @@ module ActiveRecord
         end
 
         def load_additional_types(type_map, oids = nil) # :nodoc:
+          initializer = OID::TypeMapInitializer.new(type_map)
+
           if supports_ranges?
             query = <<-SQL
               SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
@@ -571,11 +569,13 @@ module ActiveRecord
 
           if oids
             query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
+          else
+            query += initializer.query_conditions_for_initial_load(type_map)
           end
 
-          initializer = OID::TypeMapInitializer.new(type_map)
-          records = execute(query, 'SCHEMA')
-          initializer.run(records)
+          execute_and_clear(query, 'SCHEMA', []) do |records|
+            initializer.run(records)
+          end
         end
 
         FEATURE_NOT_SUPPORTED = "0A000" #:nodoc:
@@ -673,7 +673,7 @@ module ActiveRecord
           self.client_min_messages = @config[:min_messages] || 'warning'
           self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
 
-          # Use standard-conforming strings if available so we don't have to do the E'...' dance.
+          # Use standard-conforming strings so we don't have to do the E'...' dance.
           set_standard_conforming_strings
 
           # If using Active Record's time zone support configure the connection to return

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -50,16 +50,6 @@ module ActiveRecord
       end
     end
 
-    class SQLite3String < Type::String # :nodoc:
-      def type_cast_for_database(value)
-        if value.is_a?(::String) && value.encoding == Encoding::ASCII_8BIT
-          value.encode(Encoding::UTF_8)
-        else
-          super
-        end
-      end
-    end
-
     # The SQLite3 adapter works SQLite 3.6.16 or newer
     # with the sqlite3-ruby drivers (available as gem from https://rubygems.org/gems/sqlite3).
     #
@@ -84,18 +74,6 @@ module ActiveRecord
         boolean:      { name: "boolean" }
       }
 
-      class Version
-        include Comparable
-
-        def initialize(version_string)
-          @version = version_string.split('.').map { |v| v.to_i }
-        end
-
-        def <=>(version_string)
-          @version <=> version_string.split('.').map { |v| v.to_i }
-        end
-      end
-
       class StatementPool < ConnectionAdapters::StatementPool
         def initialize(connection, max)
           super
@@ -239,6 +217,12 @@ module ActiveRecord
         case value
         when BigDecimal
           value.to_f
+        when String
+          if value.encoding == Encoding::ASCII_8BIT
+            super(value.encode(Encoding::UTF_8))
+          else
+            super
+          end
         else
           super
         end
@@ -361,7 +345,7 @@ module ActiveRecord
         log('commit transaction',nil) { @connection.commit }
       end
 
-      def rollback_db_transaction #:nodoc:
+      def exec_rollback_db_transaction #:nodoc:
         log('rollback transaction',nil) { @connection.rollback }
       end
 
@@ -379,10 +363,12 @@ module ActiveRecord
           row['name']
         end
       end
+      alias data_sources tables
 
       def table_exists?(table_name)
         table_name && tables(nil, table_name).any?
       end
+      alias data_source_exists? table_exists?
 
       # Returns an array of +Column+ objects for the table specified by +table_name+.
       def columns(table_name) #:nodoc:
@@ -428,10 +414,9 @@ module ActiveRecord
       end
 
       def primary_key(table_name) #:nodoc:
-        column = table_structure(table_name).find { |field|
-          field['pk'] == 1
-        }
-        column && column['name']
+        pks = table_structure(table_name).select { |f| f['pk'] > 0 }
+        return nil unless pks.count == 1
+        pks[0]['name']
       end
 
       def remove_index!(table_name, index_name) #:nodoc:
@@ -509,7 +494,6 @@ module ActiveRecord
         def initialize_type_map(m)
           super
           m.register_type(/binary/i, SQLite3Binary.new)
-          register_class_with_limit m, %r(char)i, SQLite3String
         end
 
         def table_structure(table_name)

data/lib/active_record/connection_handling.rb

@@ -1,6 +1,6 @@
 module ActiveRecord
   module ConnectionHandling
-    RAILS_ENV   = -> { (Rails.env if defined?(Rails)) || ENV["RAILS_ENV"] || ENV["RACK_ENV"] }
+    RAILS_ENV   = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"] || ENV["RACK_ENV"] }
     DEFAULT_ENV = -> { RAILS_ENV.call || "default_env" }
 
     # Establishes the connection to the database. Accepts a hash as input where

data/lib/active_record/core.rb

@@ -114,16 +114,16 @@ module ActiveRecord
         super
       end
 
-      def initialize_find_by_cache
+      def initialize_find_by_cache # :nodoc:
         self.find_by_statement_cache = {}.extend(Mutex_m)
       end
 
-      def inherited(child_class)
+      def inherited(child_class) # :nodoc:
         child_class.initialize_find_by_cache
         super
       end
 
-      def find(*ids)
+      def find(*ids) # :nodoc:
         # We don't have cache keys for this stuff yet
         return super unless ids.length == 1
         # Allow symbols to super to maintain compatibility for deprecated finders until Rails 5
@@ -131,6 +131,7 @@ module ActiveRecord
         return super if block_given? ||
                         primary_key.nil? ||
                         default_scopes.any? ||
+                        current_scope ||
                         columns_hash.include?(inheritance_column) ||
                         ids.first.kind_of?(Array)
 
@@ -158,7 +159,7 @@ module ActiveRecord
         raise RecordNotFound, "Couldn't find #{name} with an out of range value for '#{primary_key}'"
       end
 
-      def find_by(*args)
+      def find_by(*args) # :nodoc:
         return super if current_scope || !(Hash === args.first) || reflect_on_all_aggregations.any?
         return super if default_scopes.any?
 
@@ -191,11 +192,11 @@ module ActiveRecord
         end
       end
 
-      def find_by!(*args)
+      def find_by!(*args) # :nodoc:
         find_by(*args) or raise RecordNotFound.new("Couldn't find #{name}")
       end
 
-      def initialize_generated_modules
+      def initialize_generated_modules # :nodoc:
         generated_association_methods
       end
 
@@ -270,11 +271,11 @@ module ActiveRecord
     #   User.new(first_name: 'Jamie')
     def initialize(attributes = nil, options = {})
       @attributes = self.class._default_attributes.dup
+      self.class.define_attribute_methods
 
       init_internals
       initialize_internals_callback
 
-      self.class.define_attribute_methods
       # +options+ argument is only needed to make protected_attributes gem easier to hook.
       # Remove it when we drop support to this gem.
       init_attributes(attributes, options) if attributes
@@ -283,17 +284,22 @@ module ActiveRecord
       _run_initialize_callbacks
     end
 
-    # Initialize an empty model object from +coder+. +coder+ must contain
-    # the attributes necessary for initializing an empty model object. For
-    # example:
+    # Initialize an empty model object from +coder+. +coder+ should be
+    # the result of previously encoding an Active Record model, using
+    # `encode_with`
     #
     #   class Post < ActiveRecord::Base
     #   end
     #
+    #   old_post = Post.new(title: "hello world")
+    #   coder = {}
+    #   old_post.encode_with(coder)
+    #
     #   post = Post.allocate
-    #   post.init_with('attributes' => { 'title' => 'hello world' })
+    #   post.init_with(coder)
     #   post.title # => 'hello world'
     def init_with(coder)
+      coder = LegacyYamlAdapter.convert(self.class, coder)
       @attributes = coder['attributes']
 
       init_internals
@@ -367,6 +373,7 @@ module ActiveRecord
       coder['raw_attributes'] = attributes_before_type_cast
       coder['attributes'] = @attributes
       coder['new_record'] = new_record?
+      coder['active_record_yaml_version'] = 0
     end
 
     # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
@@ -452,6 +459,7 @@ module ActiveRecord
     # Takes a PP and prettily prints this record to it, allowing you to get a nice result from `pp record`
     # when pp is required.
     def pretty_print(pp)
+      return super if custom_inspect_method_defined?
       pp.object_address_group(self) do
         if defined?(@attributes) && @attributes
           column_names = self.class.column_names.select { |name| has_attribute?(name) || new_record? }
@@ -477,16 +485,16 @@ module ActiveRecord
       Hash[methods.map! { |method| [method, public_send(method)] }].with_indifferent_access
     end
 
+    private
+
     def set_transaction_state(state) # :nodoc:
       @transaction_state = state
     end
 
     def has_transactional_callbacks? # :nodoc:
-      !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_create_callbacks.empty?
+      !_rollback_callbacks.empty? || !_commit_callbacks.empty?
     end
 
-    private
-
     # Updates the attributes on this particular ActiveRecord object so that
     # if it is associated with a transaction, then the state of the AR object
     # will be updated to reflect the current state of the transaction
@@ -509,6 +517,8 @@ module ActiveRecord
     end
 
     def update_attributes_from_transaction_state(transaction_state, depth)
+      @reflects_state = [false] if depth == 0
+
       if transaction_state && transaction_state.finalized? && !has_transactional_callbacks?
         unless @reflects_state[depth]
           restore_transaction_record_state if transaction_state.rolledback?
@@ -545,7 +555,6 @@ module ActiveRecord
       @txn                      = nil
       @_start_transaction_state = {}
       @transaction_state        = nil
-      @reflects_state           = [false]
     end
 
     def initialize_internals_callback
@@ -562,5 +571,9 @@ module ActiveRecord
         @attributes = @attributes.dup
       end
     end
+
+    def custom_inspect_method_defined?
+      self.class.instance_method(:inspect).owner != ActiveRecord::Base.instance_method(:inspect).owner
+    end
   end
 end