activerecord 5.1.0.beta1 → 5.1.0.rc1

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

@@ -1,6 +1,8 @@
 module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLTypeMetadata < DelegateClass(SqlTypeMetadata)
+      undef to_yaml if method_defined?(:to_yaml)
+
       attr_reader :oid, :fmod, :array
 
       def initialize(type_metadata, oid: nil, fmod: nil)

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -3,6 +3,7 @@ gem "pg", "~> 0.18"
 require "pg"
 
 require "active_record/connection_adapters/abstract_adapter"
+require "active_record/connection_adapters/statement_pool"
 require "active_record/connection_adapters/postgresql/column"
 require "active_record/connection_adapters/postgresql/database_statements"
 require "active_record/connection_adapters/postgresql/explain_pretty_printer"
@@ -15,7 +16,6 @@ require "active_record/connection_adapters/postgresql/schema_dumper"
 require "active_record/connection_adapters/postgresql/schema_statements"
 require "active_record/connection_adapters/postgresql/type_metadata"
 require "active_record/connection_adapters/postgresql/utils"
-require "active_record/connection_adapters/statement_pool"
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
@@ -215,7 +215,7 @@ module ActiveRecord
 
         # @local_tz is initialized as nil to avoid warnings when connect tries to use it
         @local_tz = nil
-        @table_alias_length = nil
+        @max_identifier_length = nil
 
         connect
         add_pg_encoders
@@ -281,11 +281,6 @@ module ActiveRecord
         NATIVE_DATABASE_TYPES
       end
 
-      # Returns true, since this connection adapter supports migrations.
-      def supports_migrations?
-        true
-      end
-
       def set_standard_conforming_strings
         execute("SET standard_conforming_strings = on", "SCHEMA")
       end
@@ -363,8 +358,9 @@ module ActiveRecord
 
       # Returns the configured supported identifier length supported by PostgreSQL
       def table_alias_length
-        @table_alias_length ||= query("SHOW max_identifier_length", "SCHEMA")[0][0].to_i
+        @max_identifier_length ||= select_value("SHOW max_identifier_length", "SCHEMA").to_i
       end
+      alias index_name_length table_alias_length
 
       # Set the authorized user for this session
       def session_auth=(user)
@@ -376,10 +372,6 @@ module ActiveRecord
         @use_insert_returning
       end
 
-      def valid_type?(type)
-        !native_database_types[type].nil?
-      end
-
       def update_table_definition(table_name, base) #:nodoc:
         PostgreSQL::Table.new(table_name, base)
       end

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

@@ -0,0 +1,32 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLite3
+      module SchemaStatements # :nodoc:
+        private
+          def data_source_sql(name = nil, type: nil)
+            scope = quoted_scope(name, type: type)
+            scope[:type] ||= "'table','view'"
+
+            sql = "SELECT name FROM sqlite_master WHERE name <> 'sqlite_sequence'"
+            sql << " AND name = #{scope[:name]}" if scope[:name]
+            sql << " AND type IN (#{scope[:type]})"
+            sql
+          end
+
+          def quoted_scope(name = nil, type: nil)
+            type = \
+              case type
+              when "BASE TABLE"
+                "'table'"
+              when "VIEW"
+                "'view'"
+              end
+            scope = {}
+            scope[:name] = quote(name) if name
+            scope[:type] = type if type
+            scope
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -5,6 +5,7 @@ require "active_record/connection_adapters/sqlite3/quoting"
 require "active_record/connection_adapters/sqlite3/schema_creation"
 require "active_record/connection_adapters/sqlite3/schema_definitions"
 require "active_record/connection_adapters/sqlite3/schema_dumper"
+require "active_record/connection_adapters/sqlite3/schema_statements"
 
 gem "sqlite3", "~> 1.3.6"
 require "sqlite3"
@@ -55,6 +56,7 @@ module ActiveRecord
 
       include SQLite3::Quoting
       include SQLite3::ColumnDumper
+      include SQLite3::SchemaStatements
 
       NATIVE_DATABASE_TYPES = {
         primary_key:  "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL",
@@ -117,11 +119,6 @@ module ActiveRecord
         true
       end
 
-      # Returns true, since this connection adapter supports migrations.
-      def supports_migrations? #:nodoc:
-        true
-      end
-
       def requires_reloading?
         true
       end
@@ -163,10 +160,6 @@ module ActiveRecord
         true
       end
 
-      def valid_type?(type)
-        true
-      end
-
       # Returns 62. SQLite supports index names up to 64
       # characters. The rest is used by Rails internally to perform
       # temporary rename operations
@@ -274,45 +267,6 @@ module ActiveRecord
 
       # SCHEMA STATEMENTS ========================================
 
-      def tables # :nodoc:
-        select_values("SELECT name FROM sqlite_master WHERE type = 'table' AND name <> 'sqlite_sequence'", "SCHEMA")
-      end
-
-      def data_sources # :nodoc:
-        select_values("SELECT name FROM sqlite_master WHERE type IN ('table','view') AND name <> 'sqlite_sequence'", "SCHEMA")
-      end
-
-      def views # :nodoc:
-        select_values("SELECT name FROM sqlite_master WHERE type = 'view' AND name <> 'sqlite_sequence'", "SCHEMA")
-      end
-
-      def table_exists?(table_name) # :nodoc:
-        return false unless table_name.present?
-
-        sql = "SELECT name FROM sqlite_master WHERE type = 'table' AND name <> 'sqlite_sequence'"
-        sql << " AND name = #{quote(table_name)}"
-
-        select_values(sql, "SCHEMA").any?
-      end
-
-      def data_source_exists?(table_name) # :nodoc:
-        return false unless table_name.present?
-
-        sql = "SELECT name FROM sqlite_master WHERE type IN ('table','view') AND name <> 'sqlite_sequence'"
-        sql << " AND name = #{quote(table_name)}"
-
-        select_values(sql, "SCHEMA").any?
-      end
-
-      def view_exists?(view_name) # :nodoc:
-        return false unless view_name.present?
-
-        sql = "SELECT name FROM sqlite_master WHERE type = 'view' AND name <> 'sqlite_sequence'"
-        sql << " AND name = #{quote(view_name)}"
-
-        select_values(sql, "SCHEMA").any?
-      end
-
       def new_column_from_field(table_name, field) # :nondoc:
         case field["dflt_value"]
         when /^null$/i
@@ -420,11 +374,10 @@ module ActiveRecord
 
       def change_column(table_name, column_name, type, options = {}) #:nodoc:
         alter_table(table_name) do |definition|
-          include_default = options_include_default?(options)
           definition[column_name].instance_eval do
             self.type    = type
             self.limit   = options[:limit] if options.include?(:limit)
-            self.default = options[:default] if include_default
+            self.default = options[:default] if options.include?(:default)
             self.null    = options[:null] if options.include?(:null)
             self.precision = options[:precision] if options.include?(:precision)
             self.scale = options[:scale] if options.include?(:scale)
@@ -545,7 +498,7 @@ module ActiveRecord
         end
 
         def sqlite_version
-          @sqlite_version ||= SQLite3Adapter::Version.new(select_value("select sqlite_version(*)"))
+          @sqlite_version ||= SQLite3Adapter::Version.new(select_value("SELECT sqlite_version(*)"))
         end
 
         def translate_exception(exception, message)

data/lib/active_record/core.rb

@@ -559,7 +559,6 @@ module ActiveRecord
         @marked_for_destruction   = false
         @destroyed_by_association = nil
         @new_record               = true
-        @txn                      = nil
         @_start_transaction_state = {}
         @transaction_state        = nil
       end

data/lib/active_record/gem_version.rb

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

data/lib/active_record/locking/optimistic.rb

@@ -47,8 +47,6 @@ module ActiveRecord
     #     self.locking_column = :lock_person
     #   end
     #
-    # Please note that the optimistic locking will be ignored if you update the
-    # locking column's value.
     module Optimistic
       extend ActiveSupport::Concern
 
@@ -80,13 +78,11 @@ module ActiveRecord
 
         def _update_record(attribute_names = self.attribute_names)
           return super unless locking_enabled?
-
-          lock_col = self.class.locking_column
-
-          return super if attribute_names.include?(lock_col)
           return 0 if attribute_names.empty?
 
           begin
+            lock_col = self.class.locking_column
+
             previous_lock_value = read_attribute_before_type_cast(lock_col)
 
             increment_lock

data/lib/active_record/migration.rb

@@ -548,12 +548,10 @@ module ActiveRecord
       end
 
       def call(env)
-        if connection.supports_migrations?
-          mtime = ActiveRecord::Migrator.last_migration.mtime.to_i
-          if @last_check < mtime
-            ActiveRecord::Migration.check_pending!(connection)
-            @last_check = mtime
-          end
+        mtime = ActiveRecord::Migrator.last_migration.mtime.to_i
+        if @last_check < mtime
+          ActiveRecord::Migration.check_pending!(connection)
+          @last_check = mtime
         end
         @app.call(env)
       end
@@ -1027,10 +1025,11 @@ module ActiveRecord
       def schema_migrations_table_name
         SchemaMigration.table_name
       end
+      deprecate :schema_migrations_table_name
 
       def get_all_versions(connection = Base.connection)
-        if connection.table_exists?(schema_migrations_table_name)
-          SchemaMigration.all.map { |x| x.version.to_i }.sort
+        if SchemaMigration.table_exists?
+          SchemaMigration.all_versions.map(&:to_i)
         else
           []
         end
@@ -1058,10 +1057,6 @@ module ActiveRecord
         Array(@migrations_paths)
       end
 
-      def match_to_migration_filename?(filename) # :nodoc:
-        Migration::MigrationFilenameRegexp.match?(File.basename(filename))
-      end
-
       def parse_migration_filename(filename) # :nodoc:
         File.basename(filename).scan(Migration::MigrationFilenameRegexp).first
       end
@@ -1069,9 +1064,7 @@ module ActiveRecord
       def migrations(paths)
         paths = Array(paths)
 
-        files = Dir[*paths.map { |p| "#{p}/**/[0-9]*_*.rb" }]
-
-        migrations = files.map do |file|
+        migrations = migration_files(paths).map do |file|
           version, name, scope = parse_migration_filename(file)
           raise IllegalMigrationNameError.new(file) unless version
           version = version.to_i
@@ -1083,6 +1076,30 @@ module ActiveRecord
         migrations.sort_by(&:version)
       end
 
+      def migrations_status(paths)
+        paths = Array(paths)
+
+        db_list = ActiveRecord::SchemaMigration.normalized_versions
+
+        file_list = migration_files(paths).map do |file|
+          version, name, scope = parse_migration_filename(file)
+          raise IllegalMigrationNameError.new(file) unless version
+          version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
+          status = db_list.delete(version) ? "up" : "down"
+          [status, version, (name + scope).humanize]
+        end.compact
+
+        db_list.map! do |version|
+          ["up", version, "********** NO FILE **********"]
+        end
+
+        (db_list + file_list).sort_by { |_, version, _| version }
+      end
+
+      def migration_files(paths)
+        Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
+      end
+
       private
 
       def move(direction, migrations_paths, steps)
@@ -1098,8 +1115,6 @@ module ActiveRecord
     end
 
     def initialize(direction, migrations, target_version = nil)
-      raise StandardError.new("This database does not yet support migrations") unless Base.connection.supports_migrations?
-
       @direction         = direction
       @target_version    = target_version
       @migrated_versions = nil

data/lib/active_record/null_relation.rb

@@ -4,7 +4,7 @@ module ActiveRecord
       []
     end
 
-    def delete_all(_conditions = nil)
+    def delete_all
       0
     end
 

data/lib/active_record/querying.rb

@@ -9,7 +9,7 @@ module ActiveRecord
     delegate :find_each, :find_in_batches, :in_batches, to: :all
     delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins, :left_joins, :left_outer_joins, :or,
              :where, :rewhere, :preload, :eager_load, :includes, :from, :lock, :readonly,
-             :having, :create_with, :uniq, :distinct, :references, :none, :unscope, :merge, to: :all
+             :having, :create_with, :distinct, :references, :none, :unscope, :merge, to: :all
     delegate :count, :average, :minimum, :maximum, :sum, :calculate, to: :all
     delegate :pluck, :ids, to: :all
 

data/lib/active_record/railties/databases.rake

@@ -110,28 +110,13 @@ db_namespace = namespace :db do
       unless ActiveRecord::SchemaMigration.table_exists?
         abort "Schema migrations table does not exist yet."
       end
-      db_list = ActiveRecord::SchemaMigration.normalized_versions
-
-      file_list =
-          ActiveRecord::Tasks::DatabaseTasks.migrations_paths.flat_map do |path|
-            Dir.foreach(path).map do |file|
-              next unless ActiveRecord::Migrator.match_to_migration_filename?(file)
-
-              version, name, scope = ActiveRecord::Migrator.parse_migration_filename(file)
-              version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
-              status = db_list.delete(version) ? "up" : "down"
-              [status, version, (name + scope).humanize]
-            end.compact
-          end
 
-      db_list.map! do |version|
-        ["up", version, "********** NO FILE **********"]
-      end
       # output
       puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
       puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
       puts "-" * 50
-      (db_list + file_list).sort_by { |_, version, _| version }.each do |status, version, name|
+      paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+      ActiveRecord::Migrator.migrations_status(paths).each do |status, version, name|
         puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
       end
       puts
@@ -288,8 +273,7 @@ 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? &&
-          ActiveRecord::SchemaMigration.table_exists?
+      if ActiveRecord::SchemaMigration.table_exists?
         File.open(filename, "a") do |f|
           f.puts ActiveRecord::Base.connection.dump_schema_information
           f.print "\n"

data/lib/active_record/reflection.rb

@@ -172,8 +172,8 @@ module ActiveRecord
 
       JoinKeys = Struct.new(:key, :foreign_key) # :nodoc:
 
-      def join_keys(association_klass)
-        JoinKeys.new(foreign_key, active_record_primary_key)
+      def join_keys
+        get_join_keys klass
       end
 
       # Returns a list of scopes that should be applied for this Reflection
@@ -187,6 +187,30 @@ module ActiveRecord
       end
       deprecate :scope_chain
 
+      def join_scopes(table, predicate_builder) # :nodoc:
+        if scope
+          [ActiveRecord::Relation.create(klass, table, predicate_builder)
+            .instance_exec(&scope)]
+        else
+          []
+        end
+      end
+
+      def klass_join_scope(table, predicate_builder) # :nodoc:
+        if klass.current_scope
+          klass.current_scope.clone.tap { |scope|
+            scope.joins_values = []
+          }
+        else
+          relation = ActiveRecord::Relation.create(
+            klass,
+            table,
+            predicate_builder,
+          )
+          klass.send(:build_default_scope, relation)
+        end
+      end
+
       def constraints
         chain.map(&:scopes).flatten
       end
@@ -260,6 +284,20 @@ module ActiveRecord
       def chain
         collect_join_chain
       end
+
+      def get_join_keys(association_klass)
+        JoinKeys.new(join_pk(association_klass), join_fk)
+      end
+
+      private
+
+        def join_pk(_)
+          foreign_key
+        end
+
+        def join_fk
+          active_record_primary_key
+        end
     end
 
     # Base class for AggregateReflection and AssociationReflection. Objects of
@@ -687,11 +725,6 @@ module ActiveRecord
         end
       end
 
-      def join_keys(association_klass)
-        key = polymorphic? ? association_primary_key(association_klass) : association_primary_key
-        JoinKeys.new(key, foreign_key)
-      end
-
       def join_id_for(owner) # :nodoc:
         owner[foreign_key]
       end
@@ -701,6 +734,14 @@ module ActiveRecord
         def calculate_constructable(macro, options)
           !polymorphic?
         end
+
+        def join_fk
+          foreign_key
+        end
+
+        def join_pk(klass)
+          polymorphic? ? association_primary_key(klass) : association_primary_key
+        end
     end
 
     class HasAndBelongsToManyReflection < AssociationReflection # :nodoc:
@@ -720,7 +761,7 @@ module ActiveRecord
     class ThroughReflection < AbstractReflection #:nodoc:
       attr_reader :delegate_reflection
       delegate :foreign_key, :foreign_type, :association_foreign_key,
-               :active_record_primary_key, :type, to: :source_reflection
+               :active_record_primary_key, :type, :get_join_keys, to: :source_reflection
 
       def initialize(delegate_reflection)
         @delegate_reflection = delegate_reflection
@@ -806,6 +847,10 @@ module ActiveRecord
         source_reflection.scopes + super
       end
 
+      def join_scopes(table, predicate_builder) # :nodoc:
+        source_reflection.join_scopes(table, predicate_builder) + super
+      end
+
       def source_type_scope
         through_reflection.klass.where(foreign_type => options[:source_type])
       end
@@ -816,10 +861,6 @@ module ActiveRecord
           through_reflection.has_scope?
       end
 
-      def join_keys(association_klass)
-        source_reflection.join_keys(association_klass)
-      end
-
       # A through association is nested if there would be more than one join table
       def nested?
         source_reflection.through_reflection? || through_reflection.through_reflection?
@@ -954,6 +995,7 @@ module ActiveRecord
       end
 
       private
+
         def actual_source_reflection # FIXME: this is a horrible name
           source_reflection.send(:actual_source_reflection)
         end
@@ -990,6 +1032,15 @@ module ActiveRecord
         end
       end
 
+      def join_scopes(table, predicate_builder) # :nodoc:
+        scopes = @previous_reflection.join_scopes(table, predicate_builder) + super
+        if @previous_reflection.options[:source_type]
+          scopes + [@previous_reflection.source_type_scope]
+        else
+          scopes
+        end
+      end
+
       def klass
         @reflection.klass
       end
@@ -1006,10 +1057,6 @@ module ActiveRecord
         @reflection.plural_name
       end
 
-      def join_keys(association_klass)
-        @reflection.join_keys(association_klass)
-      end
-
       def type
         @reflection.type
       end
@@ -1023,6 +1070,10 @@ module ActiveRecord
         source_type = @previous_reflection.options[:source_type]
         lambda { |object| where(type => source_type) }
       end
+
+      def get_join_keys(association_klass)
+        @reflection.get_join_keys(association_klass)
+      end
     end
 
     class RuntimeReflection < PolymorphicReflection # :nodoc: