activerecord 4.1.16 → 4.2.0.beta1

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

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Jsonb < Json # :nodoc:
+          def type
+            :jsonb
+          end
+
+          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
+            # 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))
+            super(raw_old_value, new_value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Money < Type::Decimal # :nodoc:
+          include Infinity
+
+          class_attribute :precision
+
+          def type
+            :money
+          end
+
+          def scale
+            2
+          end
+
+          def cast_value(value)
+            return value unless ::String === value
+
+            # 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
+            # Negative values are represented as follows:
+            #  (3) -$2.55
+            #  (4) ($2.55)
+
+            value.sub!(/^\((.+)\)$/, '-\1') # (4)
+            case value
+            when /^-?\D+[\d,]+\.\d{2}$/  # (1)
+              value.gsub!(/[^-\d.]/, '')
+            when /^-?\D+[\d.]+,\d{2}$/  # (2)
+              value.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
+            end
+
+            super(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Point < Type::Value # :nodoc:
+          include Type::Mutable
+
+          def type
+            :point
+          end
+
+          def type_cast(value)
+            case value
+            when ::String
+              if value[0] == '(' && value[-1] == ')'
+                value = value[1...-1]
+              end
+              type_cast(value.split(','))
+            when ::Array
+              value.map { |v| Float(v) }
+            else
+              value
+            end
+          end
+
+          def type_cast_for_database(value)
+            if value.is_a?(::Array)
+              "(#{number_for_point(value[0])},#{number_for_point(value[1])})"
+            else
+              super
+            end
+          end
+
+          private
+
+          def number_for_point(number)
+            number.to_s.gsub(/\.0$/, '')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Range < Type::Value # :nodoc:
+          attr_reader :subtype, :type
+
+          def initialize(subtype, type)
+            @subtype = subtype
+            @type = type
+          end
+
+          def type_cast_for_schema(value)
+            value.inspect.gsub('Infinity', '::Float::INFINITY')
+          end
+
+          def cast_value(value)
+            return if value == 'empty'
+            return value if value.is_a?(::Range)
+
+            extracted = extract_bounds(value)
+            from = type_cast_single extracted[:from]
+            to = type_cast_single extracted[:to]
+
+            if !infinity?(from) && extracted[:exclude_start]
+              if from.respond_to?(:succ)
+                from = from.succ
+                ActiveSupport::Deprecation.warn <<-MESSAGE
+Excluding the beginning of a Range is only partialy supported through `#succ`.
+This is not reliable and will be removed in the future.
+                MESSAGE
+              else
+                raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
+              end
+            end
+            ::Range.new(from, to, extracted[:exclude_end])
+          end
+
+          def type_cast_for_database(value)
+            if value.is_a?(::Range)
+              from = type_cast_single_for_database(value.begin)
+              to = type_cast_single_for_database(value.end)
+              "[#{from},#{to}#{value.exclude_end? ? ')' : ']'}"
+            else
+              super
+            end
+          end
+
+          private
+
+          def type_cast_single(value)
+            infinity?(value) ? value : @subtype.type_cast_from_database(value)
+          end
+
+          def type_cast_single_for_database(value)
+            infinity?(value) ? '' : @subtype.type_cast_for_database(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,
+              exclude_start: (value[0] == '('),
+              exclude_end:   (value[-1] == ')')
+            }
+          end
+
+          def infinity?(value)
+            value.respond_to?(:infinite?) && value.infinite?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class SpecializedString < Type::String # :nodoc:
+          attr_reader :type
+
+          def initialize(type)
+            @type = type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Time < Type::Time # :nodoc:
+          include Infinity
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        # This class uses the data from PostgreSQL pg_type table to build
+        # the OID -> Type mapping.
+        #   - OID is and integer representing the type.
+        #   - Type is an OID::Type object.
+        # This class has side effects on the +store+ passed during initialization.
+        class TypeMapInitializer # :nodoc:
+          def initialize(store)
+            @store = store
+          end
+
+          def run(records)
+            nodes = records.reject { |row| @store.key? row['oid'].to_i }
+            mapped, nodes = nodes.partition { |row| @store.key? row['typname'] }
+            ranges, nodes = nodes.partition { |row| row['typtype'] == 'r' }
+            enums, nodes = nodes.partition { |row| row['typtype'] == 'e' }
+            domains, nodes = nodes.partition { |row| row['typtype'] == 'd' }
+            arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }
+            composites, nodes = nodes.partition { |row| row['typelem'] != '0' }
+
+            mapped.each     { |row| register_mapped_type(row)    }
+            enums.each      { |row| register_enum_type(row)      }
+            domains.each    { |row| register_domain_type(row)    }
+            arrays.each     { |row| register_array_type(row)     }
+            ranges.each     { |row| register_range_type(row)     }
+            composites.each { |row| register_composite_type(row) }
+          end
+
+          private
+          def register_mapped_type(row)
+            alias_type row['oid'], row['typname']
+          end
+
+          def register_enum_type(row)
+            register row['oid'], OID::Enum.new
+          end
+
+          def register_array_type(row)
+            if subtype = @store.lookup(row['typelem'].to_i)
+              register row['oid'], OID::Array.new(subtype, row['typdelim'])
+            end
+          end
+
+          def register_range_type(row)
+            if subtype = @store.lookup(row['rngsubtype'].to_i)
+              register row['oid'], OID::Range.new(subtype, row['typname'].to_sym)
+            end
+          end
+
+          def register_domain_type(row)
+            if base_type = @store.lookup(row["typbasetype"].to_i)
+              register row['oid'], base_type
+            else
+              warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
+            end
+          end
+
+          def register_composite_type(row)
+            if subtype = @store.lookup(row['typelem'].to_i)
+              register row['oid'], OID::Vector.new(row['typdelim'], subtype)
+            end
+          end
+
+          def register(oid, oid_type)
+            oid = assert_valid_registration(oid, oid_type)
+            @store.register_type(oid, oid_type)
+          end
+
+          def alias_type(oid, target)
+            oid = assert_valid_registration(oid, target)
+            @store.alias_type(oid, target)
+          end
+
+          def assert_valid_registration(oid, oid_type)
+            raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
+            oid.to_i
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Uuid < Type::Value # :nodoc:
+          RFC_4122 = %r{\A\{?[a-fA-F0-9]{4}-?
+                             [a-fA-F0-9]{4}-?
+                             [a-fA-F0-9]{4}-?
+                             [1-5][a-fA-F0-9]{3}-?
+                             [8-Bab][a-fA-F0-9]{3}-?
+                             [a-fA-F0-9]{4}-?
+                             [a-fA-F0-9]{4}-?
+                             [a-fA-F0-9]{4}-?\}?\z}x
+
+          def type
+            :uuid
+          end
+
+          def type_cast(value)
+            value.to_s[RFC_4122, 0]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Vector < Type::Value # :nodoc:
+          attr_reader :delim, :subtype
+
+          # +delim+ corresponds to the `typdelim` column in the pg_types
+          # table.  +subtype+ is derived from the `typelem` column in the
+          # pg_types table.
+          def initialize(delim, subtype)
+            @delim   = delim
+            @subtype = subtype
+          end
+
+          # FIXME: this should probably split on +delim+ and use +subtype+
+          # to cast the values.  Unfortunately, the current Rails behavior
+          # is to just return the string.
+          def type_cast(value)
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Xml < Type::String # :nodoc:
+          def type
+            :xml
+          end
+
+          def type_cast_for_database(value)
+            return unless value
+            Data.new(super)
+          end
+
+          class Data # :nodoc:
+            def initialize(value)
+              @value = value
+            end
+
+            def to_s
+              @value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,142 +1,35 @@
 module ActiveRecord
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
+    module PostgreSQL
       module Quoting
         # Escapes binary strings for bytea input to the database.
         def escape_bytea(value)
-          PGconn.escape_bytea(value) if value
+          @connection.escape_bytea(value) if value
         end
 
         # Unescapes bytea output from a database to the binary string it represents.
         # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
         # on escaped binary output from database drive.
         def unescape_bytea(value)
-          PGconn.unescape_bytea(value) if value
+          @connection.unescape_bytea(value) if value
         end
 
         # Quotes PostgreSQL-specific data types for SQL input.
         def quote(value, column = nil) #:nodoc:
-          return super unless column && column.type
-
-          sql_type = type_to_sql(column.type, column.limit, column.precision, column.scale)
+          return super unless column
 
           case value
-          when Range
-            if /range$/ =~ sql_type
-              escaped = quote_string(PostgreSQLColumn.range_to_string(value))
-              "'#{escaped}'::#{sql_type}"
-            else
-              super
-            end
-          when Array
-            case sql_type
-            when 'point' then super(PostgreSQLColumn.point_to_string(value))
-            when 'json' then super(PostgreSQLColumn.json_to_string(value))
-            else
-              if column.array
-                "'#{PostgreSQLColumn.array_to_string(value, column, self).gsub(/'/, "''")}'"
-              else
-                super
-              end
-            end
-          when Hash
-            case sql_type
-            when 'hstore' then super(PostgreSQLColumn.hstore_to_string(value), column)
-            when 'json' then super(PostgreSQLColumn.json_to_string(value), column)
-            else super
-            end
-          when IPAddr
-            case sql_type
-            when 'inet', 'cidr' then super(PostgreSQLColumn.cidr_to_string(value), column)
-            else super
-            end
           when Float
-            if value.infinite? && column.type == :datetime
-              "'#{value.to_s.downcase}'"
-            elsif value.infinite? || value.nan?
+            if value.infinite? || value.nan?
               "'#{value.to_s}'"
             else
               super
             end
-          when Numeric
-            if sql_type == 'money' || [:string, :text].include?(column.type)
-              # Not truly string input, so doesn't require (or allow) escape string syntax.
-              "'#{value}'"
-            else
-              super
-            end
-          when String
-            case sql_type
-            when 'bytea' then "'#{escape_bytea(value)}'"
-            when 'xml'   then "xml '#{quote_string(value)}'"
-            when /^bit/
-              case value
-              when /\A[01]*\Z/      then "B'#{value}'" # Bit-string notation
-              when /\A[0-9A-F]*\Z/i then "X'#{value}'" # Hexadecimal notation
-              end
-            else
-              super
-            end
           else
             super
           end
         end
 
-        def type_cast(value, column, array_member = false)
-          return super(value, column) unless column
-
-          case value
-          when Range
-            if /range$/ =~ column.sql_type
-              PostgreSQLColumn.range_to_string(value)
-            else
-              super(value, column)
-            end
-          when NilClass
-            if column.array && array_member
-              'NULL'
-            elsif column.array
-              value
-            else
-              super(value, column)
-            end
-          when Array
-            case column.sql_type
-            when 'point' then PostgreSQLColumn.point_to_string(value)
-            when 'json' then PostgreSQLColumn.json_to_string(value)
-            else
-              if column.array
-                PostgreSQLColumn.array_to_string(value, column, self)
-              else
-                super(value, column)
-              end
-            end
-          when String
-            if 'bytea' == column.sql_type
-              # Return a bind param hash with format as binary.
-              # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
-              # for more information
-              { value: value, format: 1 }
-            else
-              super(value, column)
-            end
-          when Hash
-            case column.sql_type
-            when 'hstore' then PostgreSQLColumn.hstore_to_string(value, array_member)
-            when 'json' then PostgreSQLColumn.json_to_string(value)
-            else super(value, column)
-            end
-          when IPAddr
-            if %w(inet cidr).include? column.sql_type
-              PostgreSQLColumn.cidr_to_string(value)
-            else
-              super(value, column)
-            end
-          else
-            super(value, column)
-          end
-        end
-
         # Quotes strings for use in SQL input.
         def quote_string(s) #:nodoc:
           @connection.escape(s)
@@ -151,14 +44,7 @@ module ActiveRecord
         # - "schema.name".table_name
         # - "schema.name"."table.name"
         def quote_table_name(name)
-          schema, name_part = extract_pg_identifier_from_name(name.to_s)
-
-          unless name_part
-            quote_column_name(schema)
-          else
-            table_name, name_part = extract_pg_identifier_from_name(name_part)
-            "#{quote_column_name(schema)}.#{quote_column_name(table_name)}"
-          end
+          Utils.extract_schema_qualified_name(name.to_s).quoted
         end
 
         def quote_table_name_for_assignment(table, attr)
@@ -178,8 +64,9 @@ module ActiveRecord
             result = "#{result}.#{sprintf("%06d", value.usec)}"
           end
 
-          if value.year < 0
-            result = result.sub(/^-/, "") + " BC"
+          if value.year <= 0
+            bce_year = format("%04d", -value.year + 1)
+            result = result.sub(/^-?\d+/, bce_year) + " BC"
           end
           result
         end
@@ -192,6 +79,39 @@ module ActiveRecord
             quote(value, column)
           end
         end
+
+        private
+
+        def _quote(value)
+          case value
+          when Type::Binary::Data
+            "'#{escape_bytea(value.to_s)}'"
+          when OID::Xml::Data
+            "xml '#{quote_string(value.to_s)}'"
+          when OID::Bit::Data
+            if value.binary?
+              "B'#{value}'"
+            elsif value.hex?
+              "X'#{value}'"
+            end
+          else
+            super
+          end
+        end
+
+        def _type_cast(value)
+          case value
+          when Type::Binary::Data
+            # Return a bind param hash with format as binary.
+            # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
+            # for more information
+            { value: value.to_s, format: 1 }
+          when OID::Xml::Data, OID::Bit::Data
+            value.to_s
+          else
+            super
+          end
+        end
       end
     end
   end