activerecord 4.2.11.3 → 5.0.0.beta1

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

@@ -2,18 +2,14 @@ module ActiveRecord
   module ConnectionAdapters
     # PostgreSQL-specific extensions to column definitions in a table.
     class PostgreSQLColumn < Column #:nodoc:
-      attr_accessor :array
+      delegate :array, :oid, :fmod, to: :sql_type_metadata
+      alias :array? :array
 
-      def initialize(name, default, cast_type, sql_type = nil, null = true, default_function = nil)
-        if sql_type =~ /\[\]$/
-          @array = true
-          super(name, default, cast_type, sql_type[0..sql_type.length - 3], null)
-        else
-          @array = false
-          super(name, default, cast_type, sql_type, null)
-        end
+      def serial?
+        return unless default_function
 
-        @default_function = default_function
+        table_name = @table_name || '(?<table_name>.+)'
+        %r{\Anextval\('"?#{table_name}_#{name}_seq"?'::regclass\)\z} === default_function
       end
     end
   end

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

@@ -8,7 +8,7 @@ module ActiveRecord
         end
 
         class ExplainPrettyPrinter # :nodoc:
-          # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
+          # Pretty prints the result of an EXPLAIN in a way that resembles the output of the
           # PostgreSQL shell:
           #
           #                                     QUERY PLAN
@@ -156,8 +156,8 @@ module ActiveRecord
           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|

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

@@ -1,25 +1,20 @@
-require 'active_record/connection_adapters/postgresql/oid/infinity'
-
 require 'active_record/connection_adapters/postgresql/oid/array'
 require 'active_record/connection_adapters/postgresql/oid/bit'
 require 'active_record/connection_adapters/postgresql/oid/bit_varying'
 require 'active_record/connection_adapters/postgresql/oid/bytea'
 require 'active_record/connection_adapters/postgresql/oid/cidr'
-require 'active_record/connection_adapters/postgresql/oid/date'
 require 'active_record/connection_adapters/postgresql/oid/date_time'
 require 'active_record/connection_adapters/postgresql/oid/decimal'
 require 'active_record/connection_adapters/postgresql/oid/enum'
-require 'active_record/connection_adapters/postgresql/oid/float'
 require 'active_record/connection_adapters/postgresql/oid/hstore'
 require 'active_record/connection_adapters/postgresql/oid/inet'
-require 'active_record/connection_adapters/postgresql/oid/integer'
 require 'active_record/connection_adapters/postgresql/oid/json'
 require 'active_record/connection_adapters/postgresql/oid/jsonb'
 require 'active_record/connection_adapters/postgresql/oid/money'
 require 'active_record/connection_adapters/postgresql/oid/point'
+require 'active_record/connection_adapters/postgresql/oid/rails_5_1_point'
 require 'active_record/connection_adapters/postgresql/oid/range'
 require 'active_record/connection_adapters/postgresql/oid/specialized_string'
-require 'active_record/connection_adapters/postgresql/oid/time'
 require 'active_record/connection_adapters/postgresql/oid/uuid'
 require 'active_record/connection_adapters/postgresql/oid/vector'
 require 'active_record/connection_adapters/postgresql/oid/xml'

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

@@ -3,51 +3,53 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class Array < Type::Value # :nodoc:
-          include Type::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
+          include Type::Helpers::Mutable
 
           attr_reader :subtype, :delimiter
-          delegate :type, :limit, to: :subtype
+          delegate :type, :user_input_in_time_zone, :limit, to: :subtype
 
           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)
+          def deserialize(value)
             if value.is_a?(::String)
-              type_cast_array(parse_pg_array(value), :type_cast_from_database)
+              type_cast_array(@pg_decoder.decode(value), :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 = @pg_decoder.decode(value)
             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)
+              @pg_encoder.encode(type_cast_array(value, :serialize))
             else
               super
             end
           end
 
+          def ==(other)
+            other.is_a?(Array) &&
+              subtype == other.subtype &&
+              delimiter == other.delimiter
+          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
+
           private
 
           def type_cast_array(value, method)
@@ -57,42 +59,6 @@ module ActiveRecord
               @subtype.public_send(method, value)
             end
           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
-          end
-
-          ARRAY_ESCAPE = "\\" * 2 * 2 # escape the backslash twice for PG arrays
-
-          def quote_and_escape(value)
-            case value
-            when ::String
-              if string_requires_quoting?(value)
-                value = value.gsub(/\\/, ARRAY_ESCAPE)
-                value.gsub!(/"/,"\\\"")
-                %("#{value}")
-              else
-                value
-              end
-            when nil then "NULL"
-            when ::Date, ::DateTime, ::Time then subtype.type_cast_for_schema(value)
-            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

@@ -7,7 +7,7 @@ module ActiveRecord
             :bit
           end
 
-          def type_cast(value)
+          def cast(value)
             if ::String === value
               case value
               when /^0x/i
@@ -20,7 +20,7 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             Data.new(super) if value
           end
 

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

@@ -3,7 +3,7 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class Bytea < Type::Binary # :nodoc:
-          def type_cast_from_database(value)
+          def deserialize(value)
             return if value.nil?
             return value.to_s if value.is_a?(Type::Binary::Data)
             PGconn.unescape_bytea(super)

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

@@ -18,7 +18,7 @@ module ActiveRecord
             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')}"
             else

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

@@ -3,30 +3,15 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         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
-              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$/
+              astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
+              super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
             else
-              value
+              super
             end
           end
         end

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

@@ -3,13 +3,13 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class Hstore < Type::Value # :nodoc:
-          include Type::Mutable
+          include Type::Helpers::Mutable
 
           def type
             :hstore
           end
 
-          def type_cast_from_database(value)
+          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')
@@ -21,7 +21,7 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Hash)
               value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(', ')
             else

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

@@ -2,32 +2,7 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Json < Type::Value # :nodoc:
-          include Type::Mutable
-
-          def type
-            :json
-          end
-
-          def type_cast_from_database(value)
-            if value.is_a?(::String)
-              ::ActiveSupport::JSON.decode(value) rescue nil
-            else
-              super
-            end
-          end
-
-          def type_cast_for_database(value)
-            if value.is_a?(::Array) || value.is_a?(::Hash)
-              ::ActiveSupport::JSON.encode(value)
-            else
-              super
-            end
-          end
-
-          def accessor
-            ActiveRecord::Store::StringKeyedHashAccessor
-          end
+        class Json < Type::Internal::AbstractJson
         end
       end
     end

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

@@ -9,11 +9,11 @@ module ActiveRecord
 
           def changed_in_place?(raw_old_value, new_value)
             # Postgres does not preserve insignificant whitespaces when
-            # roundtripping jsonb columns. This causes some false positives for
+            # 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 = type_cast_for_database(type_cast_from_database(raw_old_value))
+            raw_old_value = serialize(deserialize(raw_old_value))
             super(raw_old_value, new_value)
           end
         end

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

@@ -3,8 +3,6 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class Money < Type::Decimal # :nodoc:
-          include Infinity
-
           class_attribute :precision
 
           def type

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

@@ -3,19 +3,19 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class Point < Type::Value # :nodoc:
-          include Type::Mutable
+          include Type::Helpers::Mutable
 
           def type
             :point
           end
 
-          def type_cast(value)
+          def cast(value)
             case value
             when ::String
               if value[0] == '(' && value[-1] == ')'
                 value = value[1...-1]
               end
-              type_cast(value.split(','))
+              cast(value.split(','))
             when ::Array
               value.map { |v| Float(v) }
             else
@@ -23,7 +23,7 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Array)
               "(#{number_for_point(value[0])},#{number_for_point(value[1])})"
             else

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

@@ -0,0 +1,50 @@
+module ActiveRecord
+  Point = Struct.new(:x, :y)
+
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Rails51Point < Type::Value # :nodoc:
+          include Type::Helpers::Mutable
+
+          def type
+            :point
+          end
+
+          def cast(value)
+            case value
+            when ::String
+              if value[0] == '(' && value[-1] == ')'
+                value = value[1...-1]
+              end
+              x, y = value.split(",")
+              build_point(x, y)
+            when ::Array
+              build_point(*value)
+            else
+              value
+            end
+          end
+
+          def serialize(value)
+            if value.is_a?(ActiveRecord::Point)
+              "(#{number_for_point(value.x)},#{number_for_point(value.y)})"
+            else
+              super
+            end
+          end
+
+          private
+
+          def number_for_point(number)
+            number.to_s.gsub(/\.0$/, '')
+          end
+
+          def build_point(x, y)
+            ActiveRecord::Point.new(Float(x), Float(y))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module ActiveRecord
         class Range < Type::Value # :nodoc:
           attr_reader :subtype, :type
 
-          def initialize(subtype, type)
+          def initialize(subtype, type = :range)
             @subtype = subtype
             @type = type
           end
@@ -25,21 +25,12 @@ module ActiveRecord
             to = type_cast_single extracted[:to]
 
             if !infinity?(from) && extracted[:exclude_start]
-              if from.respond_to?(:succ)
-                from = from.succ
-                ActiveSupport::Deprecation.warn(<<-MSG.squish)
-                  Excluding the beginning of a Range is only partialy supported
-                  through `#succ`. This is not reliable and will be removed in
-                  the future.
-                MSG
-              else
-                raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
-              end
+              raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
             end
             ::Range.new(from, to, extracted[:exclude_end])
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Range)
               from = type_cast_single_for_database(value.begin)
               to = type_cast_single_for_database(value.end)
@@ -49,26 +40,42 @@ module ActiveRecord
             end
           end
 
+          def ==(other)
+            other.is_a?(Range) &&
+              other.subtype == subtype &&
+              other.type == type
+          end
+
           private
 
           def type_cast_single(value)
-            infinity?(value) ? value : @subtype.type_cast_from_database(value)
+            infinity?(value) ? value : @subtype.deserialize(value)
           end
 
           def type_cast_single_for_database(value)
-            infinity?(value) ? '' : @subtype.type_cast_for_database(value)
+            infinity?(value) ? '' : @subtype.serialize(value)
           end
 
           def extract_bounds(value)
             from, to = value[1..-2].split(',')
             {
-              from:          (value[1] == ',' || from == '-infinity') ? @subtype.infinity(negative: true) : from,
-              to:            (value[-2] == ',' || to == 'infinity') ? @subtype.infinity : to,
+              from:          (value[1] == ',' || from == '-infinity') ? infinity(negative: true) : from,
+              to:            (value[-2] == ',' || to == 'infinity') ? infinity : to,
               exclude_start: (value[0] == '('),
               exclude_end:   (value[-1] == ')')
             }
           end
 
+          def infinity(negative: false)
+            if subtype.respond_to?(:infinity)
+              subtype.infinity(negative: negative)
+            elsif negative
+              -::Float::INFINITY
+            else
+              ::Float::INFINITY
+            end
+          end
+
           def infinity?(value)
             value.respond_to?(:infinite?) && value.infinite?
           end