activerecord 5.2.8 → 7.0.2

data/lib/active_record/connection_adapters/pool_manager.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PoolManager # :nodoc:
+      def initialize
+        @name_to_role_mapping = Hash.new { |h, k| h[k] = {} }
+      end
+
+      def shard_names
+        @name_to_role_mapping.values.flat_map { |shard_map| shard_map.keys }
+      end
+
+      def role_names
+        @name_to_role_mapping.keys
+      end
+
+      def pool_configs(role = nil)
+        if role
+          @name_to_role_mapping[role].values
+        else
+          @name_to_role_mapping.flat_map { |_, shard_map| shard_map.values }
+        end
+      end
+
+      def remove_role(role)
+        @name_to_role_mapping.delete(role)
+      end
+
+      def remove_pool_config(role, shard)
+        @name_to_role_mapping[role].delete(shard)
+      end
+
+      def get_pool_config(role, shard)
+        @name_to_role_mapping[role][shard]
+      end
+
+      def set_pool_config(role, shard, pool_config)
+        if pool_config
+          @name_to_role_mapping[role][shard] = pool_config
+        else
+          raise ArgumentError, "The `pool_config` for the :#{role} role and :#{shard} shard was `nil`. Please check your configuration. If you want your writing role to be something other than `:writing` set `config.active_record.writing_role` in your application configuration. The same setting should be applied for the `reading_role` if applicable."
+        end
+      end
+    end
+  end
+end

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

@@ -1,44 +1,69 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/blank"
+
 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
-
-      def initialize(*, max_identifier_length: 63, **)
-        super
-        @max_identifier_length = max_identifier_length
-      end
+    module PostgreSQL
+      class Column < ConnectionAdapters::Column # :nodoc:
+        delegate :oid, :fmod, to: :sql_type_metadata
 
-      def serial?
-        return unless default_function
+        def initialize(*, serial: nil, generated: nil, **)
+          super
+          @serial = serial
+          @generated = generated
+        end
 
-        if %r{\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z} =~ default_function
-          sequence_name_from_parts(table_name, name, suffix) == sequence_name
+        def serial?
+          @serial
         end
-      end
 
-      protected
-        attr_reader :max_identifier_length
+        def virtual?
+          # We assume every generated column is virtual, no matter the concrete type
+          @generated.present?
+        end
 
-      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
+        def has_default?
+          super && !virtual?
+        end
 
-          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
+        def array
+          sql_type_metadata.sql_type.end_with?("[]")
+        end
+        alias :array? :array
 
-          if over_length > 0
-            table_name = table_name[0, table_name.length - over_length]
-          end
+        def enum?
+          type == :enum
+        end
 
-          "#{table_name}_#{column_name}_#{suffix}"
+        def sql_type
+          super.delete_suffix("[]")
         end
+
+        def init_with(coder)
+          @serial = coder["serial"]
+          super
+        end
+
+        def encode_with(coder)
+          coder["serial"] = @serial
+          super
+        end
+
+        def ==(other)
+          other.is_a?(Column) &&
+            super &&
+            serial? == other.serial?
+        end
+        alias :eql? :==
+
+        def hash
+          Column.hash ^
+            super.hash ^
+            serial?.hash
+        end
+      end
     end
+    PostgreSQLColumn = PostgreSQL::Column # :nodoc:
   end
 end

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

@@ -9,67 +9,40 @@ module ActiveRecord
           PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN", binds))
         end
 
-        # The internal PostgreSQL identifier of the money data type.
-        MONEY_COLUMN_TYPE_OID = 790 #:nodoc:
-        # The internal PostgreSQL identifier of the BYTEA data type.
-        BYTEA_COLUMN_TYPE_OID = 17 #:nodoc:
-
-        # create a 2D array representing the result set
-        def result_as_array(res) #:nodoc:
-          # check if we have any binary column and if they need escaping
-          ftypes = Array.new(res.nfields) do |i|
-            [i, res.ftype(i)]
-          end
-
-          rows = res.values
-          return rows unless ftypes.any? { |_, x|
-            x == BYTEA_COLUMN_TYPE_OID || x == MONEY_COLUMN_TYPE_OID
-          }
-
-          typehash = ftypes.group_by { |_, type| type }
-          binaries = typehash[BYTEA_COLUMN_TYPE_OID] || []
-          monies   = typehash[MONEY_COLUMN_TYPE_OID] || []
-
-          rows.each do |row|
-            # unescape string passed BYTEA field (OID == 17)
-            binaries.each do |index, _|
-              row[index] = unescape_bytea(row[index])
-            end
-
-            # If this is a money type column and there are any currency symbols,
-            # then strip them off. Indeed it would be prettier to do this in
-            # PostgreSQLColumn.string_to_decimal but would break form input
-            # fields that call value_before_type_cast.
-            monies.each do |index, _|
-              data = row[index]
-              # Because money output is formatted according to the locale, there are two
-              # cases to consider (note the decimal separators):
-              #  (1) $12,345,678.12
-              #  (2) $12.345.678,12
-              case data
-              when /^-?\D+[\d,]+\.\d{2}$/  # (1)
-                data.gsub!(/[^-\d.]/, "")
-              when /^-?\D+[\d.]+,\d{2}$/  # (2)
-                data.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
-              end
-            end
-          end
-        end
-
         # Queries the database and returns the results in an Array-like object
-        def query(sql, name = nil) #:nodoc:
+        def query(sql, name = nil) # :nodoc:
+          materialize_transactions
+          mark_transaction_written_if_write(sql)
+
           log(sql, name) do
             ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              result_as_array @connection.async_exec(sql)
+              @connection.async_exec(sql).map_types!(@type_map_for_results).values
             end
           end
         end
 
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :close, :declare, :fetch, :move, :set, :show
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
+        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)
+          sql = transform_query(sql)
+          check_if_write_query(sql)
+
+          materialize_transactions
+          mark_transaction_written_if_write(sql)
+
           log(sql, name) do
             ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
               @connection.async_exec(sql)
@@ -77,25 +50,29 @@ module ActiveRecord
           end
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false)
-          execute_and_clear(sql, name, binds, prepare: prepare) do |result|
+        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:
+          execute_and_clear(sql, name, binds, prepare: prepare, async: async) do |result|
             types = {}
             fields = result.fields
             fields.each_with_index do |fname, i|
               ftype = result.ftype i
               fmod  = result.fmod i
-              types[fname] = get_oid_type(ftype, fmod, fname)
+              case type = get_oid_type(ftype, fmod, fname)
+              when Type::Integer, Type::Float, OID::Decimal, Type::String, Type::DateTime, Type::Boolean
+                # skip if a column has already been type casted by pg decoders
+              else types[fname] = type
+              end
             end
-            ActiveRecord::Result.new(fields, result.values, types)
+            build_result(columns: fields, rows: result.values, column_types: types)
           end
         end
 
-        def exec_delete(sql, name = nil, binds = [])
+        def exec_delete(sql, name = nil, binds = []) # :nodoc:
           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)
@@ -110,7 +87,7 @@ module ActiveRecord
         end
         private :sql_for_insert
 
-        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil) # :nodoc:
           if use_insert_returning? || pk == false
             super
           else
@@ -129,26 +106,42 @@ module ActiveRecord
         end
 
         # Begins a transaction.
-        def begin_db_transaction
-          execute "BEGIN"
+        def begin_db_transaction # :nodoc:
+          execute("BEGIN", "TRANSACTION")
         end
 
-        def begin_isolated_db_transaction(isolation)
+        def begin_isolated_db_transaction(isolation) # :nodoc:
           begin_db_transaction
           execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
         end
 
         # Commits a transaction.
-        def commit_db_transaction
-          execute "COMMIT"
+        def commit_db_transaction # :nodoc:
+          execute("COMMIT", "TRANSACTION")
         end
 
         # Aborts a transaction.
-        def exec_rollback_db_transaction
-          execute "ROLLBACK"
+        def exec_rollback_db_transaction # :nodoc:
+          execute("ROLLBACK", "TRANSACTION")
+        end
+
+        # From https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-CURRENT
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP").freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
         end
 
         private
+          def execute_batch(statements, name = nil)
+            execute(combine_multi_statements(statements))
+          end
+
+          def build_truncate_statements(table_names)
+            ["TRUNCATE TABLE #{table_names.map(&method(:quote_table_name)).join(", ")}"]
+          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")

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

@@ -5,7 +5,7 @@ module ActiveRecord
     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:
 
@@ -77,7 +77,6 @@ module ActiveRecord
           end
 
           private
-
             def type_cast_array(value, method)
               if value.is_a?(::Array)
                 value.map { |item| type_cast_array(item, method) }

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

@@ -43,10 +43,7 @@ module ActiveRecord
               /\A[0-9A-F]*\Z/i.match?(value)
             end
 
-            # TODO Change this to private once we've dropped Ruby 2.2 support.
-            # Workaround for Ruby 2.2 "private attribute?" warning.
-            protected
-
+            private
               attr_reader :value
           end
         end

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

@@ -12,19 +12,17 @@ module ActiveRecord
           end
 
           def type_cast_for_schema(value)
-            subnet_mask = value.instance_variable_get(:@mask_addr)
-
             # If the subnet mask is equal to /32, don't output it
-            if subnet_mask == (2**32 - 1)
+            if value.prefix == 32
               "\"#{value}\""
             else
-              "\"#{value}/#{subnet_mask.to_s(2).count('1')}\""
+              "\"#{value}/#{value.prefix}\""
             end
           end
 
           def serialize(value)
             if IPAddr === value
-              "#{value}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
+              "#{value}/#{value.prefix}"
             else
               value
             end

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

@@ -10,12 +10,20 @@ module ActiveRecord
             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))
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
             else
               super
             end
           end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
         end
       end
     end

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

@@ -10,12 +10,25 @@ module ActiveRecord
             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))
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
             else
               super
             end
           end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
+
+          protected
+            def real_type_unless_aliased(real_type)
+              ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type == real_type ? :datetime : real_type
+            end
         end
       end
     end

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

@@ -10,7 +10,6 @@ module ActiveRecord
           end
 
           private
-
             def cast_value(value)
               value.to_s
             end

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

@@ -1,26 +1,71 @@
 # frozen_string_literal: true
 
+require "strscan"
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Hstore < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          ERROR = "Invalid Hstore document: %s"
+
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :hstore
           end
 
           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')
-                [k, v]
-              }]
-            else
-              value
+            return value unless value.is_a?(::String)
+
+            scanner = StringScanner.new(value)
+            hash = {}
+
+            until scanner.eos?
+              unless scanner.skip(/"/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              unless key = scanner.scan_until(/(?<!\\)(?=")/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              unless scanner.skip(/"=>?/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              if scanner.scan(/NULL/)
+                value = nil
+              else
+                unless scanner.skip(/"/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+
+                unless value = scanner.scan_until(/(?<!\\)(?=")/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+
+                unless scanner.skip(/"/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+              end
+
+              key.gsub!('\"', '"')
+              key.gsub!("\\\\", "\\")
+
+              if value
+                value.gsub!('\"', '"')
+                value.gsub!("\\\\", "\\")
+              end
+
+              hash[key] = value
+
+              unless scanner.skip(/, /) || scanner.eos?
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
             end
+
+            hash
           end
 
           def serialize(value)
@@ -46,13 +91,6 @@ module ActiveRecord
           end
 
           private
-
-            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"

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "active_support/duration"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Interval < Type::Value # :nodoc:
+          def type
+            :interval
+          end
+
+          def cast_value(value)
+            case value
+            when ::ActiveSupport::Duration
+              value
+            when ::String
+              begin
+                ::ActiveSupport::Duration.parse(value)
+              rescue ::ActiveSupport::Duration::ISO8601Parser::ParsingError
+                nil
+              end
+            else
+              super
+            end
+          end
+
+          def serialize(value)
+            case value
+            when ::ActiveSupport::Duration
+              value.iso8601(precision: self.precision)
+            when ::Numeric
+              # Sometimes operations on Times returns just float number of seconds so we need to handle that.
+              # Example: Time.current - (Time.current + 1.hour) # => -3600.000001776 (Float)
+              value.seconds.iso8601(precision: self.precision)
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            serialize(value).inspect
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class LegacyPoint < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :point
@@ -14,7 +14,7 @@ module ActiveRecord
           def cast(value)
             case value
             when ::String
-              if value[0] == "(" && value[-1] == ")"
+              if value.start_with?("(") && value.end_with?(")")
                 value = value[1...-1]
               end
               cast(value.split(","))
@@ -34,9 +34,8 @@ module ActiveRecord
           end
 
           private
-
             def number_for_point(number)
-              number.to_s.gsub(/\.0$/, "")
+              number.to_s.delete_suffix(".0")
             end
         end
       end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Macaddr < Type::String # :nodoc:
+          def type
+            :macaddr
+          end
+
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            old_value.class != new_value.class ||
+              new_value && old_value.casecmp(new_value) != 0
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value.class != new_value.class ||
+              new_value && raw_old_value.casecmp(new_value) != 0
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Oid < Type::Integer # :nodoc:
+        class Oid < Type::UnsignedInteger # :nodoc:
           def type
             :oid
           end