activerecord-jdbc-adapter 1.3.11 → 1.3.12

data/lib/arjdbc/postgresql/base/oid.rb

@@ -6,11 +6,6 @@ module ActiveRecord
       module OID
         class Type
           def type; end
-          def simplified_type(sql_type); type end
-
-          def infinity(options = {})
-            ::Float::INFINITY * (options[:negative] ? -1 : 1)
-          end
         end
 
         class Identity < Type
@@ -19,46 +14,9 @@ module ActiveRecord
           end
         end
 
-        if ActiveRecord::VERSION::MINOR >= 2 # >= 4.2
-
-          class String < Type
-            def type; :string end
-
-            def type_cast(value)
-              return if value.nil?
-
-              value.to_s
-            end
-          end
-
-        else
-
-          # String, Text types do not exist in AR 4.0/4.1
-          # AR reports Identity for them - make it similar
-
-          class String < Identity
-            def type; :string end
-          end
-
-        end
-
-        class SpecializedString < OID::String
-          def type; @type end
-
-          def initialize(type)
-            @type = type
-          end
-        end
-
-        class Text < OID::String
-          def type; :text end
-        end
-
         class Bit < Type
-          def type; :string end
-
           def type_cast(value)
-            if ::String === value
+            if String === value
               ConnectionAdapters::PostgreSQLColumn.string_to_bit value
             else
               value
@@ -67,8 +25,6 @@ module ActiveRecord
         end
 
         class Bytea < Type
-          def type; :binary end
-
           def type_cast(value)
             return if value.nil?
             PGconn.unescape_bytea value
@@ -76,11 +32,9 @@ module ActiveRecord
         end
 
         class Money < Type
-          def type; :decimal end
-
           def type_cast(value)
             return if value.nil?
-            return value unless ::String === 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):
@@ -122,8 +76,6 @@ module ActiveRecord
         end
 
         class Point < Type
-          def type; :string end
-
           def type_cast(value)
             if ::String === value
               ConnectionAdapters::PostgreSQLColumn.string_to_point value
@@ -134,8 +86,6 @@ module ActiveRecord
         end
 
         class Array < Type
-          def type; @subtype.type end
-
           attr_reader :subtype
           def initialize(subtype)
             @subtype = subtype
@@ -152,8 +102,6 @@ module ActiveRecord
 
         class Range < Type
           attr_reader :subtype
-          def simplified_type(sql_type); sql_type.to_sym end
-
           def initialize(subtype)
             @subtype = subtype
           end
@@ -161,19 +109,23 @@ module ActiveRecord
           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(options = {})
+            ::Float::INFINITY * (options[:negative] ? -1 : 1)
+          end
+
           def infinity?(value)
             value.respond_to?(:infinite?) && value.infinite?
           end
 
-          def type_cast_single(value)
-            infinity?(value) ? value : @subtype.type_cast(value)
+          def to_integer(value)
+            infinity?(value) ? value : value.to_i
           end
 
           def type_cast(value)
@@ -181,27 +133,32 @@ module ActiveRecord
             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
+
+            case @subtype
+            when :date
+              from  = ConnectionAdapters::Column.value_to_date(extracted[:from])
+              from += 1.day if extracted[:exclude_start]
+              to    = ConnectionAdapters::Column.value_to_date(extracted[:to])
+            when :decimal
+              from  = BigDecimal.new(extracted[:from].to_s)
+              # FIXME: add exclude start for ::Range, same for timestamp ranges
+              to    = BigDecimal.new(extracted[:to].to_s)
+            when :time
+              from = ConnectionAdapters::Column.string_to_time(extracted[:from])
+              to   = ConnectionAdapters::Column.string_to_time(extracted[:to])
+            when :integer
+              from = to_integer(extracted[:from]) rescue value ? 1 : 0
+              from += 1 if extracted[:exclude_start]
+              to   = to_integer(extracted[:to]) rescue value ? 1 : 0
+            else
+              return value
             end
+
             ::Range.new(from, to, extracted[:exclude_end])
           end
         end
 
         class Integer < Type
-          def type; :integer end
-
           def type_cast(value)
             return if value.nil?
 
@@ -210,8 +167,6 @@ This is not reliable and will be removed in the future.
         end
 
         class Boolean < Type
-          def type; :boolean end
-
           def type_cast(value)
             return if value.nil?
 
@@ -221,9 +176,6 @@ This is not reliable and will be removed in the future.
 
         class Timestamp < Type
           def type; :timestamp; end
-          def simplified_type(sql_type)
-            :datetime
-          end
 
           def type_cast(value)
             return if value.nil?
@@ -235,7 +187,7 @@ This is not reliable and will be removed in the future.
         end
 
         class Date < Type
-          def type; :date; end
+          def type; :datetime; end
 
           def type_cast(value)
             return if value.nil?
@@ -247,8 +199,6 @@ This is not reliable and will be removed in the future.
         end
 
         class Time < Type
-          def type; :time end
-
           def type_cast(value)
             return if value.nil?
 
@@ -259,8 +209,6 @@ This is not reliable and will be removed in the future.
         end
 
         class Float < Type
-          def type; :float end
-
           def type_cast(value)
             case value
               when nil;         nil
@@ -274,32 +222,19 @@ This is not reliable and will be removed in the future.
         end
 
         class Decimal < Type
-          def type; :decimal end
-
           def type_cast(value)
             return if value.nil?
 
             ConnectionAdapters::Column.value_to_decimal value
           end
-
-          def infinity(options = {})
-            BigDecimal.new("Infinity") * (options[:negative] ? -1 : 1)
-          end
-        end
-
-        class Enum < Type
-          def type; :enum end
-
-          def type_cast(value)
-            value.to_s
-          end
         end
 
         class Hstore < Type
-          def type; :hstore end
-
           def type_cast_for_write(value)
-            ConnectionAdapters::PostgreSQLColumn.hstore_to_string value
+            # roundtrip to ensure uniform uniform types
+            # TODO: This is not an efficient solution.
+            stringified = ConnectionAdapters::PostgreSQLColumn.hstore_to_string(value)
+            type_cast(stringified)
           end
 
           def type_cast(value)
@@ -314,22 +249,19 @@ This is not reliable and will be removed in the future.
         end
 
         class Cidr < Type
-          def type; :cidr end
           def type_cast(value)
             return if value.nil?
 
             ConnectionAdapters::PostgreSQLColumn.string_to_cidr value
           end
         end
-        class Inet < Cidr
-          def type; :inet end
-        end
 
         class Json < Type
-          def type; :json end
-
           def type_cast_for_write(value)
-            ConnectionAdapters::PostgreSQLColumn.json_to_string value
+            # roundtrip to ensure uniform uniform types
+            # TODO: This is not an efficient solution.
+            stringified = ConnectionAdapters::PostgreSQLColumn.json_to_string(value)
+            type_cast(stringified)
           end
 
           def type_cast(value)
@@ -343,13 +275,6 @@ This is not reliable and will be removed in the future.
           end
         end
 
-        class Uuid < Type
-          def type; :uuid end
-          def type_cast(value)
-            value.presence
-          end
-        end
-
         class TypeMap
           def initialize
             @mapping = {}
@@ -396,7 +321,7 @@ This is not reliable and will be removed in the future.
         }
 
         # Register an OID type named +name+ with a typecasting object in
-        # +type+. +name+ should correspond to the `typname` column in
+        # +type+.  +name+ should correspond to the `typname` column in
         # the `pg_type` table.
         def self.register_type(name, type)
           NAMES[name] = type
@@ -413,48 +338,55 @@ This is not reliable and will be removed in the future.
         end
 
         register_type 'int2', OID::Integer.new
-        alias_type 'int4', 'int2'
-        alias_type 'int8', 'int2'
-        alias_type 'oid', 'int2'
+        alias_type    'int4', 'int2'
+        alias_type    'int8', 'int2'
+        alias_type    'oid',  'int2'
+
+        register_type 'daterange', OID::Range.new(:date)
+        register_type 'numrange', OID::Range.new(:decimal)
+        register_type 'tsrange', OID::Range.new(:time)
+        register_type 'int4range', OID::Range.new(:integer)
+        alias_type    'tstzrange', 'tsrange'
+        alias_type    'int8range', 'int4range'
+
         register_type 'numeric', OID::Decimal.new
-        register_type 'float4', OID::Float.new
-        alias_type 'float8', 'float4'
-        register_type 'text', OID::Text.new
-        register_type 'varchar', OID::String.new
-        alias_type 'char', 'varchar'
-        alias_type 'name', 'varchar'
-        alias_type 'bpchar', 'varchar'
+        register_type 'text', OID::Identity.new
+        alias_type 'varchar', 'text'
+        alias_type 'char', 'text'
+        alias_type 'bpchar', 'text'
+        alias_type 'xml', 'text'
+
+        # FIXME: why are we keeping these types as strings?
+        alias_type 'tsvector', 'text'
+        alias_type 'interval', 'text'
+        alias_type 'macaddr',  'text'
+        alias_type 'uuid',     'text'
+
+        register_type 'money', OID::Money.new
+        register_type 'bytea', OID::Bytea.new
         register_type 'bool', OID::Boolean.new
         register_type 'bit', OID::Bit.new
-        alias_type 'varbit', 'bit'
+        register_type 'varbit', OID::Bit.new
+
+        register_type 'float4', OID::Float.new
+        alias_type 'float8', 'float4'
+
         register_type 'timestamp', OID::Timestamp.new
-        alias_type 'timestamptz', 'timestamp'
+        register_type 'timestamptz', OID::Timestamp.new
         register_type 'date', OID::Date.new
         register_type 'time', OID::Time.new
 
-        register_type 'money', OID::Money.new
-        register_type 'bytea', OID::Bytea.new
+        register_type 'path', OID::Identity.new
         register_type 'point', OID::Point.new
+        register_type 'polygon', OID::Identity.new
+        register_type 'circle', OID::Identity.new
         register_type 'hstore', OID::Hstore.new
         register_type 'json', OID::Json.new
-        register_type 'cidr', OID::Cidr.new
-        register_type 'inet', OID::Inet.new
-        register_type 'uuid', OID::Uuid.new
-        register_type 'xml', SpecializedString.new(:xml)
-        register_type 'tsvector', SpecializedString.new(:tsvector)
-        register_type 'macaddr', SpecializedString.new(:macaddr)
-        register_type 'citext', SpecializedString.new(:citext)
-        register_type 'ltree', SpecializedString.new(:ltree)
+        register_type 'ltree', OID::Identity.new
 
-        # FIXME: why are we keeping these types as strings?
-        alias_type 'interval', 'varchar'
-        alias_type 'path', 'varchar'
-        alias_type 'line', 'varchar'
-        alias_type 'polygon', 'varchar'
-        alias_type 'circle', 'varchar'
-        alias_type 'lseg', 'varchar'
-        alias_type 'box', 'varchar'
+        register_type 'cidr', OID::Cidr.new
+        alias_type 'inet', 'cidr'
       end
     end
   end
-end
+end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -1,19 +1,20 @@
-require 'arjdbc/postgresql/base/oid' # 'active_record/connection_adapters/postgresql/oid'
 require 'thread'
 
 module ArJdbc
   module PostgreSQL
+
+    if AR42_COMPAT
+      require 'active_record/connection_adapters/postgresql/oid'
+    else
+      require 'arjdbc/postgresql/base/oid'
+    end
+
     # @private
     module OIDTypes
 
       OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
-      def get_oid_type(oid, fmod, column_name)
-        type_map.fetch(oid, fmod) {
-          warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
-          type_map[oid] = OID::Identity.new
-        }
-      end
+      Type = ActiveRecord::Type if AR42_COMPAT
 
       # @override
       def enable_extension(name)
@@ -36,13 +37,40 @@ module ArJdbc
         @extensions ||= super
       end
 
+      def get_oid_type(oid, fmod, column_name)
+        type_map.fetch(oid, fmod) {
+          warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+          type_map[oid] = OID::Identity.new
+        }
+      end unless AR42_COMPAT
+
+      def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
+        if !type_map.key?(oid)
+          load_additional_types(type_map, [oid])
+        end
+
+        type_map.fetch(oid, fmod, sql_type) {
+          warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+          Type::Value.new.tap do |cast_type|
+            type_map.register_type(oid, cast_type)
+          end
+        }
+      end if AR42_COMPAT
+
       private
 
       @@type_map_cache = {}
       @@type_map_cache_lock = Mutex.new
 
+      if AR42_COMPAT
+        TypeMap = ActiveRecord::Type::HashLookupTypeMap
+      else
+        TypeMap = OID::TypeMap
+      end
+
+      # @see #type_map
       # @private
-      class OID::TypeMap
+      TypeMap.class_eval do
         def dup
           dup = super # make sure @mapping is not shared
           dup.instance_variable_set(:@mapping, @mapping.dup)
@@ -56,7 +84,7 @@ module ArJdbc
           if type_map = @@type_map_cache[ type_cache_key ]
             type_map.dup
           else
-            type_map = OID::TypeMap.new
+            type_map = TypeMap.new
             initialize_type_map(type_map)
             cache_type_map(type_map)
             type_map
@@ -120,7 +148,101 @@ module ArJdbc
           array = OID::Array.new  type_map[ row['typelem'].to_i ]
           type_map[ row['oid'].to_i ] = array
         end
-      end
+      end unless AR42_COMPAT
+
+      def initialize_type_map(m) # :nodoc:
+        register_class_with_limit m, 'int2', OID::Integer
+        m.alias_type 'int4', 'int2'
+        m.alias_type 'int8', 'int2'
+        m.alias_type 'oid', 'int2'
+        m.register_type 'float4', OID::Float.new
+        m.alias_type 'float8', 'float4'
+        m.register_type 'text', Type::Text.new
+        register_class_with_limit m, 'varchar', Type::String
+        m.alias_type 'char', 'varchar'
+        m.alias_type 'name', 'varchar'
+        m.alias_type 'bpchar', 'varchar'
+        m.register_type 'bool', Type::Boolean.new
+        register_class_with_limit m, 'bit', OID::Bit
+        register_class_with_limit m, 'varbit', OID::BitVarying
+        m.alias_type 'timestamptz', 'timestamp'
+        m.register_type 'date', OID::Date.new
+        m.register_type 'time', OID::Time.new
+
+        m.register_type 'money', OID::Money.new
+        m.register_type 'bytea', OID::Bytea.new
+        m.register_type 'point', OID::Point.new
+        m.register_type 'hstore', OID::Hstore.new
+        m.register_type 'json', OID::Json.new
+        m.register_type 'jsonb', OID::Jsonb.new
+        m.register_type 'cidr', OID::Cidr.new
+        m.register_type 'inet', OID::Inet.new
+        m.register_type 'uuid', OID::Uuid.new
+        m.register_type 'xml', OID::Xml.new
+        m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
+        m.register_type 'macaddr', OID::SpecializedString.new(:macaddr)
+        m.register_type 'citext', OID::SpecializedString.new(:citext)
+        m.register_type 'ltree', OID::SpecializedString.new(:ltree)
+
+        # FIXME: why are we keeping these types as strings?
+        m.alias_type 'interval', 'varchar'
+        m.alias_type 'path', 'varchar'
+        m.alias_type 'line', 'varchar'
+        m.alias_type 'polygon', 'varchar'
+        m.alias_type 'circle', 'varchar'
+        m.alias_type 'lseg', 'varchar'
+        m.alias_type 'box', 'varchar'
+
+        m.register_type 'timestamp' do |_, _, sql_type|
+          precision = extract_precision(sql_type)
+          OID::DateTime.new(precision: precision)
+        end
+
+        m.register_type 'numeric' do |_, fmod, sql_type|
+          precision = extract_precision(sql_type)
+          scale = extract_scale(sql_type)
+
+          # The type for the numeric depends on the width of the field,
+          # so we'll do something special here.
+          #
+          # When dealing with decimal columns:
+          #
+          # places after decimal  = fmod - 4 & 0xffff
+          # places before decimal = (fmod - 4) >> 16 & 0xffff
+          if fmod && (fmod - 4 & 0xffff).zero?
+            # FIXME: Remove this class, and the second argument to
+            # lookups on PG
+            Type::DecimalWithoutScale.new(precision: precision)
+          else
+            OID::Decimal.new(precision: precision, scale: scale)
+          end
+        end
+
+        load_additional_types(m)
+      end if AR42_COMPAT
+
+      def load_additional_types(type_map, oids = nil) # :nodoc:
+        if supports_ranges?
+          query = <<-SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
+            FROM pg_type as t
+            LEFT JOIN pg_range as r ON oid = rngtypid
+          SQL
+        else
+          query = <<-SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype
+            FROM pg_type as t
+          SQL
+        end
+
+        if oids
+          query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
+        end
+
+        initializer = OID::TypeMapInitializer.new(type_map)
+        records = execute(query, 'SCHEMA')
+        initializer.run(records)
+      end if AR42_COMPAT
 
     end
   end