activerecord-jdbc-adapter 5.0.pre1 → 50.0

data/lib/arjdbc/oracle/column.rb

@@ -1,126 +0,0 @@
-module ArJdbc
-  module Oracle
-
-    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
-    def self.column_selector
-      [ /oracle/i, lambda { |config, column| column.extend(Column) } ]
-    end
-
-    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
-    module Column
-
-      def self.included(base)
-        # NOTE: assumes a standalone OracleColumn class
-        class << base; include Cast; end # unless AR42
-      end
-
-      def primary=(value)
-        super
-        @type = :integer if value && @sql_type =~ /^NUMBER$/i
-      end unless AR42
-
-      def type_cast(value)
-        return nil if value.nil?
-        case type
-        when :datetime  then self.class.string_to_time(value)
-        when :timestamp then self.class.string_to_time(value)
-        when :boolean   then self.class.value_to_boolean(value)
-        else
-          super
-        end
-      end
-
-      def type_cast_code(var_name)
-        case type
-        when :datetime  then "#{self.class.name}.string_to_time(#{var_name})"
-        when :timestamp then "#{self.class.name}.string_to_time(#{var_name})"
-        when :boolean   then "#{self.class.name}.value_to_boolean(#{var_name})"
-        else
-          super
-        end
-      end
-
-      def sql_type
-        (@sql_type || '').start_with?('XMLTYPE') ? 'XMLTYPE' : @sql_type
-      end
-
-      private
-
-      def extract_limit(sql_type)
-        case sql_type
-        when /^(clob|date)/i then nil
-        when /^xml/i then nil
-        else super
-        end
-      end unless AR42
-
-      def simplified_type(field_type)
-        case field_type
-        when /char/i            then :string
-        when /float|double/i    then :float
-        when /int/i             then :integer
-        when /^number\(1\)$/i   then Oracle.emulate_booleans? ? :boolean : :integer
-        when /^num|dec|real/i   then extract_scale(field_type) == 0 ? :integer : :decimal
-        # Oracle TIMESTAMP stores the date and time to up to 9 digits of sub-second precision
-        when /TIMESTAMP/i       then :timestamp
-        # Oracle DATE stores the date and time to the second
-        when /DATE|TIME/i       then :datetime
-        when /CLOB/i            then :text
-        when /BLOB/i            then :binary
-        when /XML/i             then :xml
-        else
-          super
-        end
-      end unless AR42
-
-      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
-      def default_value(value)
-        return nil unless value
-        value = value.strip # Not sure why we need this for Oracle?
-        upcase = value.upcase
-
-        return nil if upcase == "NULL"
-        # SYSDATE default should be treated like a NULL value
-        return nil if upcase == "SYSDATE"
-        # jdbc returns column default strings with actual single quotes around the value.
-        return $1 if value =~ /^'(.*)'$/
-
-        value
-      end
-
-      module Cast
-
-        # Convert a value to a boolean.
-        def value_to_boolean(value)
-          # NOTE: Oracle JDBC meta-data gets us DECIMAL for NUMBER(1) values
-          # thus we're likely to get a column back as BigDecimal (e.g. 1.0)
-          if value.is_a?(String)
-            value.blank? ? nil : value == '1'
-          elsif value.is_a?(Numeric)
-            value.to_i == 1 # <BigDecimal:7b5bfe,'0.1E1',1(4)>
-          else
-            !! value
-          end
-        end
-
-        # @override
-        def string_to_time(string)
-          return string unless string.is_a?(String)
-          return nil if string.empty?
-          return Time.now if string.index('CURRENT') == 0 # TODO seems very wrong
-
-          super(string)
-        end
-
-        # @private
-        def guess_date_or_time(value)
-          return value if value.is_a? Date
-          ( value && value.hour == 0 && value.min == 0 && value.sec == 0 ) ?
-            Date.new(value.year, value.month, value.day) : value
-        end
-
-      end
-
-    end
-  end
-end

data/lib/arjdbc/oracle/connection_methods.rb

@@ -1,21 +0,0 @@
-ArJdbc::ConnectionMethods.module_eval do
-  # Unless a connection URL (`url: jdbc:oracle:...`) is specified we'll use the
-  # *thin* method to connect to the Oracle DB.
-  # @note Oracle's JDBC driver should be on the class-path.
-  def oracle_connection(config)
-    config[:adapter_spec] ||= ::ArJdbc::Oracle
-    config[:adapter_class] = ActiveRecord::ConnectionAdapters::OracleAdapter unless config.key?(:adapter_class)
-
-    return jndi_connection(config) if jndi_config?(config)
-
-    config[:port] ||= 1521
-    config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database] || 'XE'}"
-    config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
-    config[:connection_alive_sql] ||= 'SELECT 1 FROM DUAL'
-    unless config.key?(:statement_escape_processing)
-      config[:statement_escape_processing] = true
-    end
-    jdbc_connection(config)
-  end
-  alias_method :jdbcoracle_connection, :oracle_connection
-end

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

@@ -1,412 +0,0 @@
-# copied from active_record/connection_adapters/postgresql/oid.rb
-# until it's some day shareable with Rails ... this is not public API !
-module ActiveRecord
-  module ConnectionAdapters
-    module PostgreSQL
-      module OID
-        class Type
-          def type; end
-        end
-
-        class Identity < Type
-          def type_cast(value)
-            value
-          end
-        end
-
-        class Bit < Type
-          def type_cast(value)
-            if String === value
-              ConnectionAdapters::PostgreSQLColumn.string_to_bit value
-            else
-              value
-            end
-          end
-        end
-
-        class Bytea < Type
-          def type_cast(value)
-            return if value.nil?
-            PGconn.unescape_bytea value
-          end
-        end
-
-        class Money < Type
-          def type_cast(value)
-            return if value.nil?
-            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
-
-            ConnectionAdapters::Column.value_to_decimal value
-          end
-        end
-
-        class Vector < Type
-          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
-
-        class Point < Type
-          def type_cast(value)
-            if ::String === value
-              ConnectionAdapters::PostgreSQLColumn.string_to_point value
-            else
-              value
-            end
-          end
-        end
-
-        class Array < Type
-          attr_reader :subtype
-          def initialize(subtype)
-            @subtype = subtype
-          end
-
-          def type_cast(value)
-            if ::String === value
-              ConnectionAdapters::PostgreSQLColumn.string_to_array value, @subtype
-            else
-              value
-            end
-          end
-        end
-
-        class Range < Type
-          attr_reader :subtype
-          def initialize(subtype)
-            @subtype = subtype
-          end
-
-          def extract_bounds(value)
-            from, to = value[1..-2].split(',')
-            {
-              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 to_integer(value)
-            infinity?(value) ? value : value.to_i
-          end
-
-          def type_cast(value)
-            return if value.nil? || value == 'empty'
-            return value if value.is_a?(::Range)
-
-            extracted = extract_bounds(value)
-
-            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_cast(value)
-            return if value.nil?
-
-            ConnectionAdapters::Column.value_to_integer value
-          end
-        end
-
-        class Boolean < Type
-          def type_cast(value)
-            return if value.nil?
-
-            ConnectionAdapters::Column.value_to_boolean value
-          end
-        end
-
-        class Timestamp < Type
-          def type; :timestamp; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            # FIXME: probably we can improve this since we know it is PG
-            # specific
-            ConnectionAdapters::PostgreSQLColumn.string_to_time value
-          end
-        end
-
-        class Date < Type
-          def type; :datetime; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            # FIXME: probably we can improve this since we know it is PG
-            # specific
-            ConnectionAdapters::Column.value_to_date value
-          end
-        end
-
-        class Time < Type
-          def type_cast(value)
-            return if value.nil?
-
-            # FIXME: probably we can improve this since we know it is PG
-            # specific
-            ConnectionAdapters::Column.string_to_dummy_time value
-          end
-        end
-
-        class Float < Type
-          def type_cast(value)
-            case value
-              when nil;         nil
-              when 'Infinity';  ::Float::INFINITY
-              when '-Infinity'; -::Float::INFINITY
-              when 'NaN';       ::Float::NAN
-            else
-              value.to_f
-            end
-          end
-        end
-
-        class Decimal < Type
-          def type_cast(value)
-            return if value.nil?
-
-            ConnectionAdapters::Column.value_to_decimal value
-          end
-        end
-
-        class Hstore < Type
-          def type_cast_for_write(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)
-            return if value.nil?
-
-            ConnectionAdapters::PostgreSQLColumn.string_to_hstore value
-          end
-
-          def accessor
-            ActiveRecord::Store::StringKeyedHashAccessor
-          end
-        end
-
-        class Cidr < Type
-          def type_cast(value)
-            return if value.nil?
-
-            ConnectionAdapters::PostgreSQLColumn.string_to_cidr value
-          end
-        end
-
-        class Json < Type
-          def type_cast_for_write(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)
-            return if value.nil?
-
-            ConnectionAdapters::PostgreSQLColumn.string_to_json value
-          end
-
-          def accessor
-            ActiveRecord::Store::StringKeyedHashAccessor
-          end
-        end
-
-        class Jsonb < Type
-          def type_cast_for_write(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)
-            return if value.nil?
-
-            ConnectionAdapters::PostgreSQLColumn.string_to_json value
-          end
-
-          def accessor
-            ActiveRecord::Store::StringKeyedHashAccessor
-          end
-        end
-
-        class TypeMap
-          def initialize
-            @mapping = {}
-          end
-
-          def []=(oid, type)
-            @mapping[oid] = type
-          end
-
-          def [](oid)
-            @mapping[oid]
-          end
-
-          def clear
-            @mapping.clear
-          end
-
-          def key?(oid)
-            @mapping.key? oid
-          end
-
-          def fetch(ftype, fmod)
-            # 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 ftype == 1700 && (fmod - 4 & 0xffff).zero?
-              ftype = 23
-            end
-
-            @mapping.fetch(ftype) { |oid| yield oid, fmod }
-          end
-        end
-
-        # When the PG adapter connects, the pg_type table is queried. The
-        # key of this hash maps to the `typname` column from the table.
-        # type_map is then dynamically built with oids as the key and type
-        # objects as values.
-        NAMES = Hash.new { |h,k| # :nodoc:
-          h[k] = OID::Identity.new
-        }
-
-        # Register an OID type named +name+ with a typecasting object in
-        # +type+.  +name+ should correspond to the `typname` column in
-        # the `pg_type` table.
-        def self.register_type(name, type)
-          NAMES[name] = type
-        end
-
-        # Alias the +old+ type to the +new+ type.
-        def self.alias_type(new, old)
-          NAMES[new] = NAMES[old]
-        end
-
-        # Is +name+ a registered type?
-        def self.registered_type?(name)
-          NAMES.key? name
-        end
-
-        register_type 'int2', OID::Integer.new
-        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 '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
-        register_type 'varbit', OID::Bit.new
-
-        register_type 'float4', OID::Float.new
-        alias_type 'float8', 'float4'
-
-        register_type 'timestamp', OID::Timestamp.new
-        register_type 'timestamptz', OID::Timestamp.new
-        register_type 'date', OID::Date.new
-        register_type 'time', OID::Time.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 'jsonb', OID::Jsonb.new
-        register_type 'ltree', OID::Identity.new
-
-        register_type 'cidr', OID::Cidr.new
-        alias_type 'inet', 'cidr'
-      end
-    end
-  end
-end