activerecord 4.2.0 → 6.1.7.1

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

@@ -1,215 +1,114 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module DatabaseStatements
         def explain(arel, binds = [])
           sql = "EXPLAIN #{to_sql(arel, binds)}"
-          ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
-        end
-
-        class ExplainPrettyPrinter # :nodoc:
-          # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
-          # PostgreSQL shell:
-          #
-          #                                     QUERY PLAN
-          #   ------------------------------------------------------------------------------
-          #    Nested Loop Left Join  (cost=0.00..37.24 rows=8 width=0)
-          #      Join Filter: (posts.user_id = users.id)
-          #      ->  Index Scan using users_pkey on users  (cost=0.00..8.27 rows=1 width=4)
-          #            Index Cond: (id = 1)
-          #      ->  Seq Scan on posts  (cost=0.00..28.88 rows=8 width=4)
-          #            Filter: (posts.user_id = 1)
-          #   (6 rows)
-          #
-          def pp(result)
-            header = result.columns.first
-            lines  = result.rows.map(&:first)
-
-            # We add 2 because there's one char of padding at both sides, note
-            # the extra hyphens in the example above.
-            width = [header, *lines].map(&:length).max + 2
-
-            pp = []
-
-            pp << header.center(width).rstrip
-            pp << '-' * width
-
-            pp += lines.map {|line| " #{line}"}
-
-            nrows = result.rows.length
-            rows_label = nrows == 1 ? 'row' : 'rows'
-            pp << "(#{nrows} #{rows_label})"
-
-            pp.join("\n") + "\n"
-          end
+          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
+        # Queries the database and returns the results in an Array-like object
+        def query(sql, name = nil) #:nodoc:
+          materialize_transactions
+          mark_transaction_written_if_write(sql)
 
-        def select_values(arel, name = nil)
-          arel, binds = binds_from_relation arel, []
-          sql = to_sql(arel, binds)
-          execute_and_clear(sql, name, binds) do |result|
-            if result.nfields > 0
-              result.column_values(0)
-            else
-              []
+          log(sql, name) do
+            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              @connection.async_exec(sql).map_types!(@type_map_for_results).values
             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
-        end
-
-        # Executes an INSERT query and returns the new record's ID
-        def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-          unless pk
-            # 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
-
-          if pk && use_insert_returning?
-            select_value("#{sql} RETURNING #{quote_column_name(pk)}")
-          elsif pk
-            super
-            last_insert_id_value(sequence_name || default_sequence_name(table_ref, pk))
-          else
-            super
-          end
-        end
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :close, :declare, :fetch, :move, :set, :show
+        ) # :nodoc:
+        private_constant :READ_QUERY
 
-        def create
-          super.insert
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         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
+        # 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
-        end
 
-        # Queries the database and returns the results in an Array-like object
-        def query(sql, name = nil) #:nodoc:
-          log(sql, name) do
-            result_as_array @connection.async_exec(sql)
-          end
-        end
+          materialize_transactions
+          mark_transaction_written_if_write(sql)
 
-        # Executes an SQL statement, returning a PGresult object on success
-        # or raising a PGError exception otherwise.
-        def execute(sql, name = nil)
           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 = [])
-          execute_and_clear(sql, name, binds) do |result|
+        def exec_query(sql, name = "SQL", binds = [], prepare: false)
+          execute_and_clear(sql, name, binds, prepare: prepare) 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 = '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)
-          unless pk
+        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
 
-          if pk && use_insert_returning?
+          if pk = suppress_composite_primary_key(pk)
             sql = "#{sql} RETURNING #{quote_column_name(pk)}"
           end
 
-          [sql, binds]
+          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
 
-        # Executes an UPDATE query and returns the number of affected tuples.
-        def update_sql(sql, name = nil)
-          super.cmd_tuples
-        end
-
         # Begins a transaction.
         def begin_db_transaction
-          execute "BEGIN"
+          execute("BEGIN", "TRANSACTION")
         end
 
         def begin_isolated_db_transaction(isolation)
@@ -219,13 +118,31 @@ module ActiveRecord
 
         # Commits a transaction.
         def commit_db_transaction
-          execute "COMMIT"
+          execute("COMMIT", "TRANSACTION")
         end
 
         # Aborts a transaction.
-        def rollback_db_transaction
-          execute "ROLLBACK"
+        def exec_rollback_db_transaction
+          execute("ROLLBACK", "TRANSACTION")
         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")
+          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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of an EXPLAIN in a way that resembles the output of the
+        # PostgreSQL shell:
+        #
+        #                                     QUERY PLAN
+        #   ------------------------------------------------------------------------------
+        #    Nested Loop Left Join  (cost=0.00..37.24 rows=8 width=0)
+        #      Join Filter: (posts.user_id = users.id)
+        #      ->  Index Scan using users_pkey on users  (cost=0.00..8.27 rows=1 width=4)
+        #            Index Cond: (id = 1)
+        #      ->  Seq Scan on posts  (cost=0.00..28.88 rows=8 width=4)
+        #            Filter: (posts.user_id = 1)
+        #   (6 rows)
+        #
+        def pp(result)
+          header = result.columns.first
+          lines  = result.rows.map(&:first)
+
+          # We add 2 because there's one char of padding at both sides, note
+          # the extra hyphens in the example above.
+          width = [header, *lines].map(&:length).max + 2
+
+          pp = []
+
+          pp << header.center(width).rstrip
+          pp << "-" * width
+
+          pp += lines.map { |line| " #{line}" }
+
+          nrows = result.rows.length
+          rows_label = nrows == 1 ? "row" : "rows"
+          pp << "(#{nrows} #{rows_label})"
+
+          pp.join("\n") + "\n"
+        end
+      end
+    end
+  end
+end

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

@@ -1,97 +1,89 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Array < Type::Value # :nodoc:
-          include Type::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
-          # Loads pg_array_parser if available. String parsing can be
-          # performed quicker by a native extension, which will not create
-          # a large amount of Ruby objects that will need to be garbage
-          # collected. pg_array_parser has a C and Java extension
-          begin
-            require 'pg_array_parser'
-            include PgArrayParser
-          rescue LoadError
-            require 'active_record/connection_adapters/postgresql/array_parser'
-            include PostgreSQL::ArrayParser
-          end
+          Data = Struct.new(:encoder, :values) # :nodoc:
 
           attr_reader :subtype, :delimiter
-          delegate :type, 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
+
+            @pg_encoder = PG::TextEncoder::Array.new name: "#{type}[]", delimiter: delimiter
+            @pg_decoder = PG::TextDecoder::Array.new name: "#{type}[]", delimiter: delimiter
           end
 
-          def type_cast_from_database(value)
-            if value.is_a?(::String)
-              type_cast_array(parse_pg_array(value), :type_cast_from_database)
+          def deserialize(value)
+            case value
+            when ::String
+              type_cast_array(@pg_decoder.decode(value), :deserialize)
+            when Data
+              type_cast_array(value.values, :deserialize)
             else
               super
             end
           end
 
-          def type_cast_from_user(value)
+          def cast(value)
             if value.is_a?(::String)
-              value = parse_pg_array(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, :type_cast_from_user)
+            type_cast_array(value, :cast)
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Array)
-              cast_value_for_database(value)
+              casted_values = type_cast_array(value, :serialize)
+              Data.new(@pg_encoder, casted_values)
             else
               super
             end
           end
 
-          private
+          def ==(other)
+            other.is_a?(Array) &&
+              subtype == other.subtype &&
+              delimiter == other.delimiter
+          end
 
-          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
+          def type_cast_for_schema(value)
+            return super unless value.is_a?(::Array)
+            "[" + value.map { |v| subtype.type_cast_for_schema(v) }.join(", ") + "]"
           end
 
-          def cast_value_for_database(value)
-            if value.is_a?(::Array)
-              casted_values = value.map { |item| cast_value_for_database(item) }
-              "{#{casted_values.join(delimiter)}}"
-            else
-              quote_and_escape(subtype.type_cast_for_database(value))
-            end
+          def map(value, &block)
+            value.map(&block)
           end
 
-          ARRAY_ESCAPE = "\\" * 2 * 2 # escape the backslash twice for PG arrays
+          def changed_in_place?(raw_old_value, new_value)
+            deserialize(raw_old_value) != new_value
+          end
 
-          def quote_and_escape(value)
-            case value
-            when ::String
-              if string_requires_quoting?(value)
-                value = value.gsub(/\\/, ARRAY_ESCAPE)
-                value.gsub!(/"/,"\\\"")
-                %("#{value}")
+          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
-                value
+                @subtype.public_send(method, value)
               end
-            when nil then "NULL"
-            else value
             end
-          end
-
-          # See http://www.postgresql.org/docs/9.2/static/arrays.html#ARRAYS-IO
-          # for a list of all cases in which strings will be quoted.
-          def string_requires_quoting?(string)
-            string.empty? ||
-              string == "NULL" ||
-              string =~ /[\{\}"\\\s]/ ||
-              string.include?(delimiter)
-          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
@@ -7,7 +9,7 @@ module ActiveRecord
             :bit
           end
 
-          def type_cast(value)
+          def cast_value(value)
             if ::String === value
               case value
               when /^0x/i
@@ -16,11 +18,11 @@ module ActiveRecord
                 value                    # Bit-string notation
               end
             else
-              value
+              value.to_s
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             Data.new(super) if value
           end
 
@@ -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,11 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Bytea < Type::Binary # :nodoc:
-          def type_cast_from_database(value)
+          def deserialize(value)
             return if value.nil?
-            PGconn.unescape_bytea(super)
+            return value.to_s if value.is_a?(Type::Binary::Data)
+            PG::Connection.unescape_bytea(super)
           end
         end
       end

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

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -8,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 type_cast_for_database(value)
+          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

@@ -1,9 +1,21 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Date < Type::Date # :nodoc:
-          include Infinity
+          def cast_value(value)
+            case value
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
+            when / BC$/
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
+            else
+              super
+            end
+          end
         end
       end
     end

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

@@ -1,23 +1,27 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class DateTime < Type::DateTime # :nodoc:
-          include Infinity
-
           def cast_value(value)
-            if value.is_a?(::String)
-              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
+            case value
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
+            when / BC$/
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
             else
-              value
+              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