activerecord 5.0.6 → 6.0.1

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,31 +1,30 @@
-require 'active_record/connection_adapters/abstract_mysql_adapter'
-require 'active_record/connection_adapters/mysql/database_statements'
+# frozen_string_literal: true
 
-gem 'mysql2', '>= 0.3.18', '< 0.5'
-require 'mysql2'
-raise 'mysql2 0.4.3 is not supported. Please upgrade to 0.4.4+' if Mysql2::VERSION == '0.4.3'
+require "active_record/connection_adapters/abstract_mysql_adapter"
+require "active_record/connection_adapters/mysql/database_statements"
+
+gem "mysql2", ">= 0.4.4"
+require "mysql2"
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
+    ER_BAD_DB_ERROR = 1049
+
     # Establishes a connection to the database that's used by all Active Record objects.
     def mysql2_connection(config)
       config = config.symbolize_keys
-
-      config[:username] = 'root' if config[:username].nil?
       config[:flags] ||= 0
 
-      if Mysql2::Client.const_defined? :FOUND_ROWS
-        if config[:flags].kind_of? Array
-          config[:flags].push "FOUND_ROWS".freeze
-        else
-          config[:flags] |= Mysql2::Client::FOUND_ROWS
-        end
+      if config[:flags].kind_of? Array
+        config[:flags].push "FOUND_ROWS"
+      else
+        config[:flags] |= Mysql2::Client::FOUND_ROWS
       end
 
       client = Mysql2::Client.new(config)
       ConnectionAdapters::Mysql2Adapter.new(client, logger, nil, config)
     rescue Mysql2::Error => error
-      if error.message.include?("Unknown database")
+      if error.error_number == ER_BAD_DB_ERROR
         raise ActiveRecord::NoDatabaseError
       else
         raise
@@ -35,18 +34,24 @@ module ActiveRecord
 
   module ConnectionAdapters
     class Mysql2Adapter < AbstractMysqlAdapter
-      ADAPTER_NAME = 'Mysql2'.freeze
+      ADAPTER_NAME = "Mysql2"
 
       include MySQL::DatabaseStatements
 
       def initialize(connection, logger, connection_options, config)
-        super
-        @prepared_statements = false unless config.key?(:prepared_statements)
+        superclass_config = config.reverse_merge(prepared_statements: false)
+        super(connection, logger, connection_options, superclass_config)
         configure_connection
       end
 
+      def self.database_exists?(config)
+        !!ActiveRecord::Base.mysql2_connection(config)
+      rescue ActiveRecord::NoDatabaseError
+        false
+      end
+
       def supports_json?
-        !mariadb? && version >= '5.7.8'
+        !mariadb? && database_version >= "5.7.8"
       end
 
       def supports_comments?
@@ -61,11 +66,15 @@ module ActiveRecord
         true
       end
 
+      def supports_lazy_transactions?
+        true
+      end
+
       # HELPER METHODS ===========================================
 
       def each_hash(result) # :nodoc:
         if block_given?
-          result.each(:as => :hash, :symbolize_keys => true) do |row|
+          result.each(as: :hash, symbolize_keys: true) do |row|
             yield row
           end
         else
@@ -107,21 +116,31 @@ module ActiveRecord
         @connection.close
       end
 
+      def discard! # :nodoc:
+        super
+        @connection.automatic_close = false
+        @connection = nil
+      end
+
       private
 
-      def connect
-        @connection = Mysql2::Client.new(@config)
-        configure_connection
-      end
+        def connect
+          @connection = Mysql2::Client.new(@config)
+          configure_connection
+        end
 
-      def configure_connection
-        @connection.query_options.merge!(:as => :array)
-        super
-      end
+        def configure_connection
+          @connection.query_options[:as] = :array
+          super
+        end
 
-      def full_version
-        @full_version ||= @connection.server_info[:version]
-      end
+        def full_version
+          schema_cache.database_version.full_version_string
+        end
+
+        def get_full_version
+          @connection.server_info[:version]
+        end
     end
   end
 end

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

@@ -1,15 +1,30 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
-    # PostgreSQL-specific extensions to column definitions in a table.
-    class PostgreSQLColumn < Column #:nodoc:
-      delegate :array, :oid, :fmod, to: :sql_type_metadata
-      alias :array? :array
+    module PostgreSQL
+      class Column < ConnectionAdapters::Column # :nodoc:
+        delegate :oid, :fmod, to: :sql_type_metadata
+
+        def initialize(*, serial: nil, **)
+          super
+          @serial = serial
+        end
+
+        def serial?
+          @serial
+        end
 
-      def serial?
-        return unless default_function
+        def array
+          sql_type_metadata.sql_type.end_with?("[]")
+        end
+        alias :array? :array
 
-        %r{\Anextval\('"?#{table_name}_#{name}_seq"?'::regclass\)\z} === default_function
+        def sql_type
+          super.sub(/\[\]\z/, "")
+        end
       end
     end
+    PostgreSQLColumn = PostgreSQL::Column # :nodoc:
   end
 end

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

@@ -1,38 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module DatabaseStatements
         def explain(arel, binds = [])
           sql = "EXPLAIN #{to_sql(arel, binds)}"
-          PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
-        end
-
-        def select_value(arel, name = nil, binds = [])
-          arel, binds = binds_from_relation arel, binds
-          sql = to_sql(arel, binds)
-          execute_and_clear(sql, name, binds) do |result|
-            result.getvalue(0, 0) if result.ntuples > 0 && result.nfields > 0
-          end
-        end
-
-        def select_values(arel, name = nil, binds = [])
-          arel, binds = binds_from_relation arel, binds
-          sql = to_sql(arel, binds)
-          execute_and_clear(sql, name, binds) do |result|
-            if result.nfields > 0
-              result.column_values(0)
-            else
-              []
-            end
-          end
-        end
-
-        # Executes a SELECT query and returns an array of rows. Each row is an
-        # array of field values.
-        def select_rows(sql, name = nil, binds = [])
-          execute_and_clear(sql, name, binds) do |result|
-            result.values
-          end
+          PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN", binds))
         end
 
         # The internal PostgreSQL identifier of the money data type.
@@ -74,9 +48,9 @@ module ActiveRecord
               #  (2) $12.345.678,12
               case data
               when /^-?\D+[\d,]+\.\d{2}$/  # (1)
-                data.gsub!(/[^-\d.]/, '')
+                data.gsub!(/[^-\d.]/, "")
               when /^-?\D+[\d.]+,\d{2}$/  # (2)
-                data.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
+                data.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
               end
             end
           end
@@ -84,22 +58,43 @@ module ActiveRecord
 
         # Queries the database and returns the results in an Array-like object
         def query(sql, name = nil) #:nodoc:
+          materialize_transactions
+
           log(sql, name) do
-            result_as_array @connection.async_exec(sql)
+            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              result_as_array @connection.async_exec(sql)
+            end
           end
         end
 
-        # Executes an SQL statement, returning a PGresult object on success
-        # or raising a PGError exception otherwise.
-        # Note: the PGresult object is manually memory managed; if you don't
-        # need it specifically, you many want consider the exec_query wrapper.
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :with
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        end
+
+        # Executes an SQL statement, returning a PG::Result object on success
+        # or raising a PG::Error exception otherwise.
+        # Note: the PG::Result object is manually memory managed; if you don't
+        # need it specifically, you may want consider the <tt>exec_query</tt> wrapper.
         def execute(sql, name = nil)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
+          materialize_transactions
+
           log(sql, name) do
-            @connection.async_exec(sql)
+            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              @connection.async_exec(sql)
+            end
           end
         end
 
-        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+        def exec_query(sql, name = "SQL", binds = [], prepare: false)
           execute_and_clear(sql, name, binds, prepare: prepare) do |result|
             types = {}
             fields = result.fields
@@ -112,38 +107,41 @@ module ActiveRecord
           end
         end
 
-        def exec_delete(sql, name = 'SQL', binds = [])
-          execute_and_clear(sql, name, binds) {|result| result.cmd_tuples }
+        def exec_delete(sql, name = nil, binds = [])
+          execute_and_clear(sql, name, binds) { |result| result.cmd_tuples }
         end
         alias :exec_update :exec_delete
 
-        def sql_for_insert(sql, pk, id_value, sequence_name, binds) # :nodoc:
+        def sql_for_insert(sql, pk, binds) # :nodoc:
           if pk.nil?
             # Extract the table from the insert sql. Yuck.
             table_ref = extract_table_ref_from_insert_sql(sql)
             pk = primary_key(table_ref) if table_ref
           end
 
-          pk = suppress_composite_primary_key(pk)
-
-          if pk && use_insert_returning?
+          if pk = suppress_composite_primary_key(pk)
             sql = "#{sql} RETURNING #{quote_column_name(pk)}"
           end
 
           super
         end
+        private :sql_for_insert
 
-        def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-          val = exec_query(sql, name, binds)
-          if !use_insert_returning? && pk
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+          if use_insert_returning? || pk == false
+            super
+          else
+            result = exec_query(sql, name, binds)
             unless sequence_name
               table_ref = extract_table_ref_from_insert_sql(sql)
-              sequence_name = default_sequence_name(table_ref, pk)
-              return val unless sequence_name
+              if table_ref
+                pk = primary_key(table_ref) if pk.nil?
+                pk = suppress_composite_primary_key(pk)
+                sequence_name = default_sequence_name(table_ref, pk)
+              end
+              return result unless sequence_name
             end
             last_insert_id_result(sequence_name)
-          else
-            val
           end
         end
 
@@ -168,10 +166,18 @@ module ActiveRecord
         end
 
         private
+          def build_truncate_statements(*table_names)
+            "TRUNCATE TABLE #{table_names.map(&method(:quote_table_name)).join(", ")}"
+          end
 
-        def suppress_composite_primary_key(pk)
-          pk unless pk.is_a?(Array)
-        end
+          # Returns the current ID of a table's sequence.
+          def last_insert_id_result(sequence_name)
+            exec_query("SELECT currval(#{quote(sequence_name)})", "SQL")
+          end
+
+          def suppress_composite_primary_key(pk)
+            pk unless pk.is_a?(Array)
+          end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -26,12 +28,12 @@ module ActiveRecord
           pp = []
 
           pp << header.center(width).rstrip
-          pp << '-' * width
+          pp << "-" * width
 
-          pp += lines.map {|line| " #{line}"}
+          pp += lines.map { |line| " #{line}" }
 
           nrows = result.rows.length
-          rows_label = nrows == 1 ? 'row' : 'rows'
+          rows_label = nrows == 1 ? "row" : "rows"
           pp << "(#{nrows} #{rows_label})"
 
           pp.join("\n") + "\n"

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

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Array < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           Data = Struct.new(:encoder, :values) # :nodoc:
 
           attr_reader :subtype, :delimiter
-          delegate :type, :user_input_in_time_zone, :limit, to: :subtype
+          delegate :type, :user_input_in_time_zone, :limit, :precision, :scale, to: :subtype
 
-          def initialize(subtype, delimiter = ',')
+          def initialize(subtype, delimiter = ",")
             @subtype = subtype
             @delimiter = delimiter
 
@@ -31,7 +33,13 @@ module ActiveRecord
 
           def cast(value)
             if value.is_a?(::String)
-              value = @pg_decoder.decode(value)
+              value = begin
+                @pg_decoder.decode(value)
+              rescue TypeError
+                # malformed array string is treated as [], will raise in PG 2.0 gem
+                # this keeps a consistent implementation
+                []
+              end
             end
             type_cast_array(value, :cast)
           end
@@ -64,15 +72,19 @@ module ActiveRecord
             deserialize(raw_old_value) != new_value
           end
 
+          def force_equality?(value)
+            value.is_a?(::Array)
+          end
+
           private
 
-          def type_cast_array(value, method)
-            if value.is_a?(::Array)
-              value.map { |item| type_cast_array(item, method) }
-            else
-              @subtype.public_send(method, value)
+            def type_cast_array(value, method)
+              if value.is_a?(::Array)
+                value.map { |item| type_cast_array(item, method) }
+              else
+                @subtype.public_send(method, value)
+              end
             end
-          end
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -34,16 +36,15 @@ module ActiveRecord
             end
 
             def binary?
-              /\A[01]*\Z/ === value
+              /\A[01]*\Z/.match?(value)
             end
 
             def hex?
-              /\A[0-9A-F]*\Z/i === value
+              /\A[0-9A-F]*\Z/i.match?(value)
             end
 
-            protected
-
-            attr_reader :value
+            private
+              attr_reader :value
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL

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

@@ -1,4 +1,6 @@
-require 'ipaddr'
+# frozen_string_literal: true
+
+require "ipaddr"
 
 module ActiveRecord
   module ConnectionAdapters

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Date < Type::Date # :nodoc:
+          def cast_value(value)
+            case value
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
+            when / BC$/
+              astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
+              super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -5,8 +7,8 @@ module ActiveRecord
         class DateTime < Type::DateTime # :nodoc:
           def cast_value(value)
             case value
-            when 'infinity' then ::Float::INFINITY
-            when '-infinity' then -::Float::INFINITY
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
             when / BC$/
               astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
               super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Decimal < Type::Decimal # :nodoc:
           def infinity(options = {})
-            BigDecimal.new("Infinity") * (options[:negative] ? -1 : 1)
+            BigDecimal("Infinity") * (options[:negative] ? -1 : 1)
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -9,9 +11,9 @@ module ActiveRecord
 
           private
 
-          def cast_value(value)
-            value.to_s
-          end
+            def cast_value(value)
+              value.to_s
+            end
         end
       end
     end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Hstore < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :hstore
@@ -12,8 +14,8 @@ module ActiveRecord
           def deserialize(value)
             if value.is_a?(::String)
               ::Hash[value.scan(HstorePair).map { |k, v|
-                v = v.upcase == 'NULL' ? nil : v.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
-                k = k.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
+                v = v.upcase == "NULL" ? nil : v.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
+                k = k.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
                 [k, v]
               }]
             else
@@ -23,7 +25,7 @@ module ActiveRecord
 
           def serialize(value)
             if value.is_a?(::Hash)
-              value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(', ')
+              value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(", ")
             elsif value.respond_to?(:to_unsafe_h)
               serialize(value.to_unsafe_h)
             else
@@ -45,23 +47,23 @@ module ActiveRecord
 
           private
 
-          HstorePair = begin
-            quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
-            unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
-            /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
-          end
+            HstorePair = begin
+              quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+              unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+              /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
+            end
 
-          def escape_hstore(value)
-            if value.nil?
-              'NULL'
-            else
-              if value == ""
-                '""'
+            def escape_hstore(value)
+              if value.nil?
+                "NULL"
               else
-                '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
+                if value == ""
+                  '""'
+                else
+                  '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
+                end
               end
             end
-          end
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL

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

@@ -1,21 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Jsonb < Json # :nodoc:
+        class Jsonb < Type::Json # :nodoc:
           def type
             :jsonb
           end
-
-          def changed_in_place?(raw_old_value, new_value)
-            # Postgres does not preserve insignificant whitespaces when
-            # round-tripping jsonb columns. This causes some false positives for
-            # the comparison here. Therefore, we need to parse and re-dump the
-            # raw value here to ensure the insignificant whitespaces are
-            # consistent with our encoder's output.
-            raw_old_value = serialize(deserialize(raw_old_value))
-            super(raw_old_value, new_value)
-          end
         end
       end
     end