activerecord-jdbc-adapter 1.0.3-java → 50.1-java

data/lib/arjdbc/jdbc/extension.rb

@@ -1,47 +1,59 @@
 module ArJdbc
-  # Defines an AR-JDBC extension. An extension consists of a
-  # declaration using this method and an ArJdbc::XYZ module that
-  # contains implementation and overrides for methods in
-  # ActiveRecord::ConnectionAdapters::AbstractAdapter. When you
-  # declare your extension, you provide a block that detects when a
-  # database configured to use the extension is present and loads the
-  # necessary code for it. AR-JDBC will patch the code into the base
-  # ActiveRecord::ConnectionAdapters::JdbcAdapter by extending an
-  # instance of it with your extension module.
+
+  # Defines an AR-JDBC extension. An extension consists of a declaration using
+  # this method and an ArJdbc::XYZ module that contains implementation and
+  # overrides for methods in ActiveRecord::ConnectionAdapters::AbstractAdapter.
+  # When you declare your extension, you provide a block that detects when a
+  # database configured to use the extension is present and loads the necessary
+  # code for it. AR-JDBC will patch the code into the base JdbcAdapter by
+  # extending an instance of it with your extension module.
   #
-  # +name+ should be a symbol that is the name of a module to be
-  # defined under the +ArJdbc+ module.
+  # +name+ the name of a module to be defined under the +ArJdbc+ module.
   #
-  # +block+ should be a one- or two-arity block that receives the
-  # dialect name or driver class name as the first argument, and
-  # optionally the whole database configuration hash as a second
-  # argument.
+  # +block+ should be a one- or two-arity block that receives the dialect name
+  # or driver class name as the first argument, and optionally the whole
+  # database configuration hash as a second argument
   #
   # Example:
   #
-  #     ArJdbc.extension :Frob do |name|
-  #       if name =~ /frob/i
-  #         # arjdbc/frob.rb should contain the implementation
-  #         require 'arjdbc/frob'
-  #         true
-  #       end
+  #   ArJdbc.extension :FRoB do |name|
+  #     if name =~ /frob/i
+  #       require 'arjdbc/frob' # contains ArJdbc::FRoB
+  #       true
   #     end
-  def self.extension(name,&block)
+  #   end
+  #
+  def self.extension(name, &block)
     if const_defined?(name)
       mod = const_get(name)
     else
       mod = const_set(name, Module.new)
     end
     (class << mod; self; end).instance_eval do
-      unless respond_to?(:adapter_matcher)
-        define_method :adapter_matcher do |name, config|
-          if block.arity == 1
-            block.call(name) ? mod : false
-          else
-            block.call(name, config) ? mod : false
-          end
+      define_method :adapter_matcher do |_name, config|
+        if block.arity == 1
+          block.call(_name) ? mod : false
+        else
+          block.call(_name, config) ? mod : false
         end
       end
+    end unless mod.respond_to?(:adapter_matcher)
+  end
+
+  private
+  def self.discover_extensions
+    if defined?(Gem) && Gem.respond_to?(:find_files)
+      files = Gem.find_files('arjdbc/discover')
+    else
+      files = $LOAD_PATH.map do |path|
+        discover = File.join(path, 'arjdbc', 'discover.rb')
+        File.exist?(discover) ? discover : nil
+      end.compact
+    end
+    files.each do |file|
+      puts "Loading AR-JDBC extension #{file}" if $DEBUG
+      require file
     end
   end
+
 end

data/lib/arjdbc/jdbc/java.rb

@@ -4,11 +4,10 @@ require 'arjdbc/jdbc/adapter_java'
 module ActiveRecord
   module ConnectionAdapters
     module Jdbc
-      Mutex = java.lang.Object.new
-      DriverManager = java.sql.DriverManager
-      Types = java.sql.Types
+      # @private
+      DriverManager = ::Java::JavaSql::DriverManager
+      # @private
+      Types = ::Java::JavaSql::Types
     end
-
-    java_import "arjdbc.jdbc.JdbcConnectionFactory"
   end
-end
+end

data/lib/arjdbc/jdbc/jdbc.rake

@@ -1,127 +1,4 @@
-def redefine_task(*args, &block)
-  task_name = Hash === args.first ? args.first.keys[0] : args.first
-  existing_task = Rake.application.lookup task_name
-  if existing_task
-    class << existing_task
-      public :instance_variable_set
-      attr_reader :actions
-    end
-    existing_task.instance_variable_set "@prerequisites", FileList[]
-    existing_task.actions.shift
-    enhancements = existing_task.actions
-    existing_task.instance_variable_set "@actions", []
-  end
-  redefined_task = task(*args, &block)
-  enhancements.each {|enhancement| redefined_task.actions << enhancement}
-end
+load 'arjdbc/tasks.rb'
 
-def rails_env
-  defined?(Rails.env) ? Rails.env : RAILS_ENV
-end
-
-namespace :db do
-  redefine_task :create => :rails_env do
-    create_database(ActiveRecord::Base.configurations[rails_env])
-  end
-  task :create => :load_config if Rake.application.lookup(:load_config)
-
-  redefine_task :drop => :environment do
-    config = ActiveRecord::Base.configurations[rails_env]
-    begin
-      db = find_database_name(config)
-      ActiveRecord::Base.connection.drop_database(db)
-    rescue
-      drop_database(config.merge('adapter' => config['adapter'].sub(/^jdbc/, '')))
-    end
-  end
-  task :drop => :load_config if Rake.application.lookup(:load_config)
-
-  namespace :create do
-    task :all => :rails_env
-  end
-
-  namespace :drop do
-    task :all => :environment
-  end
-
-  class << self
-    alias_method :previous_create_database, :create_database
-    alias_method :previous_drop_database, :drop_database
-  end
-
-  def find_database_name(config)
-    db = config['database']
-    if config['adapter'] =~ /postgresql/i
-      config = config.dup
-      if config['url']
-        db = config['url'][/\/([^\/]*)$/, 1]
-        config['url'][/\/([^\/]*)$/, 1] = 'postgres' if db
-      else
-        db = config['database']
-        config['database'] = 'postgres'
-      end
-      ActiveRecord::Base.establish_connection(config)
-    else
-      ActiveRecord::Base.establish_connection(config)
-      db = ActiveRecord::Base.connection.database_name
-    end
-    db
-  end
-
-  def create_database(config)
-    begin
-      ActiveRecord::Base.establish_connection(config)
-      ActiveRecord::Base.connection
-    rescue
-      begin
-        if url = config['url'] && url =~ /^(.*(?<!\/)\/)(?=\w)/
-          url = $1
-        end
-
-        ActiveRecord::Base.establish_connection(config.merge({'database' => nil, 'url' => url}))
-        ActiveRecord::Base.connection.create_database(config['database'])
-        ActiveRecord::Base.establish_connection(config)
-      rescue => e
-        raise e unless config['adapter'] =~ /mysql|postgresql|sqlite/
-        previous_create_database(config.merge('adapter' => config['adapter'].sub(/^jdbc/, '')))
-      end
-    end
-  end
-
-  def drop_database(config)
-    previous_drop_database(config.merge('adapter' => config['adapter'].sub(/^jdbc/, '')))
-  end
-
-  namespace :structure do
-    redefine_task :dump => :environment do
-      abcs = ActiveRecord::Base.configurations
-      ActiveRecord::Base.establish_connection(abcs[rails_env])
-      File.open("db/#{rails_env}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
-      if ActiveRecord::Base.connection.supports_migrations?
-        File.open("db/#{rails_env}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
-      end
-    end
-  end
-
-  namespace :test do
-    redefine_task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
-      abcs = ActiveRecord::Base.configurations
-      abcs['test']['pg_params'] = '?allowEncodingChanges=true' if abcs['test']['adapter'] =~ /postgresql/i
-      ActiveRecord::Base.establish_connection(abcs["test"])
-      ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0') if abcs["test"]["adapter"] =~ /mysql/i
-      IO.readlines("db/#{rails_env}_structure.sql").join.split(";\n\n").each do |ddl|
-        begin
-          ActiveRecord::Base.connection.execute(ddl.chomp(';'))
-        rescue Exception => ex
-          puts ex.message
-        end
-      end
-    end
-
-    redefine_task :purge => :environment do
-      abcs = ActiveRecord::Base.configurations
-      db = find_database_name(abcs['test'])
-      ActiveRecord::Base.connection.recreate_database(db)
-    end
-  end
-end
+require 'arjdbc'
+ArJdbc.deprecate "load 'arjdbc/tasks.rb' (or 'arjdbc/tasks/database.rake') instead of 'arjdbc/jdbc/jdbc.rake'"

data/lib/arjdbc/jdbc/railtie.rb

@@ -1,9 +1,2 @@
-require 'rails/railtie'
-
-module ::ArJdbc
-  class Railtie < ::Rails::Railtie
-    rake_tasks do
-      load File.expand_path('../rake_tasks.rb', __FILE__)
-    end
-  end
-end
+require 'arjdbc/railtie'
+ArJdbc.deprecate "require 'arjdbc/railtie' instead of 'arjdbc/jdbc/railtie'"

data/lib/arjdbc/jdbc/rake_tasks.rb

@@ -1,10 +1,3 @@
-if defined?(Rake.application) && Rake.application && ENV["SKIP_AR_JDBC_RAKE_REDEFINES"].nil?
-  jdbc_rakefile = File.dirname(__FILE__) + "/jdbc.rake"
-  if Rake.application.lookup("db:create")
-    # rails tasks already defined; load the override tasks now
-    load jdbc_rakefile
-  else
-    # rails tasks not loaded yet; load as an import
-    Rake.application.add_import(jdbc_rakefile)
-  end
-end
+load 'arjdbc/tasks.rb'
+
+ArJdbc.deprecate "load 'arjdbc/tasks.rb' instead of 'arjdbc/jdbc/rake_tasks.rb'"

data/lib/arjdbc/jdbc/serialized_attributes_helper.rb

@@ -0,0 +1,3 @@
+require 'arjdbc/util/serialized_attributes'
+
+ArJdbc.deprecate "require 'arjdbc/util/serialized_attributes' instead of 'arjdbc/jdbc/serialized_attributes_helper'"

data/lib/arjdbc/jdbc/type_cast.rb

@@ -0,0 +1,166 @@
+require 'active_record/connection_adapters/column'
+
+module ActiveRecord::ConnectionAdapters
+  module Jdbc
+    # Type casting methods taken from AR 4.1's Column class.
+    # @private Simply to quickly "hack-in" 4.2 compatibility.
+    module TypeCast
+      TRUE_VALUES = Column::TRUE_VALUES if Column.const_defined?(:TRUE_VALUES)
+      FALSE_VALUES = if defined?(ActiveModel::Type::Boolean::FALSE_VALUES)
+        ActiveModel::Type::Boolean::FALSE_VALUES
+      else
+        Column::FALSE_VALUES
+      end
+
+      #module Format
+      ISO_DATE = if defined?(ActiveModel::Type::Date::ISO_DATE)
+        ActiveModel::Type::Date::ISO_DATE
+      else
+        Column::Format::ISO_DATE
+      end
+
+      ISO_DATETIME = if defined?(ActiveModel::Type::Helpers::TimeValue::ISO_DATETIME)
+        ActiveModel::Type::Helpers::TimeValue::ISO_DATETIME
+      else
+        Column::Format::ISO_DATETIME
+      end
+      #end
+
+      # Used to convert from BLOBs to Strings
+      def binary_to_string(value)
+        value
+      end
+
+      def value_to_date(value)
+        if value.is_a?(String)
+          return nil if value.empty?
+          fast_string_to_date(value) || fallback_string_to_date(value)
+        elsif value.respond_to?(:to_date)
+          value.to_date
+        else
+          value
+        end
+      end
+
+      def string_to_time(string)
+        return string unless string.is_a?(String)
+        return nil if string.empty?
+        return string if string =~ /^-?infinity$/.freeze
+
+        fast_string_to_time(string) || fallback_string_to_time(string)
+      end
+
+      def string_to_dummy_time(string)
+        return string unless string.is_a?(String)
+        return nil if string.empty?
+
+        dummy_time_string = "2000-01-01 #{string}"
+
+        fast_string_to_time(dummy_time_string) || begin
+          time_hash = Date._parse(dummy_time_string)
+          return nil if time_hash[:hour].nil?
+          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+        end
+      end
+
+      # convert something to a boolean
+      def value_to_boolean(value)
+        if value.is_a?(String) && value.empty?
+          nil
+        else
+          TRUE_VALUES.include?(value)
+        end
+      end if const_defined?(:TRUE_VALUES) # removed on AR 5.0
+
+      # convert something to a boolean
+      def value_to_boolean(value)
+        if value.is_a?(String) && value.empty?
+          nil
+        else
+          ! FALSE_VALUES.include?(value)
+        end
+      end unless const_defined?(:TRUE_VALUES)
+
+      # Used to convert values to integer.
+      # handle the case when an integer column is used to store boolean values
+      def value_to_integer(value)
+        case value
+        when TrueClass, FalseClass
+          value ? 1 : 0
+        else
+          value.to_i rescue nil
+        end
+      end
+
+      # convert something to a BigDecimal
+      def value_to_decimal(value)
+        # Using .class is faster than .is_a? and
+        # subclasses of BigDecimal will be handled
+        # in the else clause
+        if value.class == BigDecimal
+          value
+        elsif value.respond_to?(:to_d)
+          value.to_d
+        else
+          value.to_s.to_d
+        end
+      end
+
+      protected
+        # '0.123456' -> 123456
+        # '1.123456' -> 123456
+        def microseconds(time)
+          time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
+        end
+
+        def new_date(year, mon, mday)
+          if year && year != 0
+            Date.new(year, mon, mday) rescue nil
+          end
+        end
+
+        def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
+          # Treat 0000-00-00 00:00:00 as nil.
+          return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
+
+          if offset
+            time = Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
+            return nil unless time
+
+            time -= offset
+            ActiveRecord::Base.default_timezone == :utc ? time : time.getlocal
+          else
+            timezone = ActiveRecord::Base.default_timezone
+            Time.public_send(timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+          end
+        end
+
+        def fast_string_to_date(string)
+          if string =~ ISO_DATE
+            new_date $1.to_i, $2.to_i, $3.to_i
+          end
+        end
+
+        # Doesn't handle time zones.
+        def fast_string_to_time(string)
+          if string =~ ISO_DATETIME
+            microsec = ($7.to_r * 1_000_000).to_i
+            new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+          end
+        end
+
+        def fallback_string_to_date(string)
+          new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+        end
+
+        def fallback_string_to_time(string)
+          time_hash = Date._parse(string)
+          time_hash[:sec_fraction] = microseconds(time_hash)
+          time_hash[:year] *= -1 if time_hash[:zone] == 'BC'
+
+          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+        end
+
+    end
+  end
+end

data/lib/arjdbc/jdbc/type_converter.rb

@@ -5,10 +5,23 @@ module ActiveRecord
     # but apparently a database driver can return multiple types for a given
     # java.sql.Types constant.  So this type converter uses some heuristics to try to pick
     # the best (most common) type to use.  It's not great, it would be better to just
-    # delegate to each database's existin AR adapter's native_database_types method, but I
+    # delegate to each database's existing AR adapter's native_database_types method, but I
     # wanted to try to do this in a way that didn't pull in all the other adapters as
-    # dependencies.  Suggestions appreciated.
+    # dependencies. Improvements appreciated.
     class JdbcTypeConverter
+
+      # @private
+      TEXT_TYPES = [ Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB ]
+      private_constant :TEXT_TYPES if respond_to? :private_constant
+
+      # @private
+      FLOAT_TYPES = [ Jdbc::Types::FLOAT, Jdbc::Types::DOUBLE, Jdbc::Types::REAL ]
+      private_constant :FLOAT_TYPES if respond_to? :private_constant
+
+      # @private
+      BINARY_TYPES = [ Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB ]
+      private_constant :BINARY_TYPES if respond_to? :private_constant
+
       # The basic ActiveRecord types, mapped to an array of procs that are used to #select
       # the best type.  The procs are used as selectors in order until there is only one
       # type left.  If all the selectors are applied and there is still more than one
@@ -18,7 +31,7 @@ module ActiveRecord
                           lambda {|r| r['type_name'] =~ /^varchar/i},
                           lambda {|r| r['type_name'] =~ /^varchar$/i},
                           lambda {|r| r['type_name'] =~ /varying/i}],
-        :text        => [ lambda {|r| [Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB].include?(r['data_type'].to_i)},
+        :text        => [ lambda {|r| TEXT_TYPES.include?(r['data_type'].to_i)},
                           lambda {|r| r['type_name'] =~ /^text$/i},     # For Informix
                           lambda {|r| r['type_name'] =~ /sub_type 1$/i}, # For FireBird
                           lambda {|r| r['type_name'] =~ /^(text|clob)$/i},
@@ -34,8 +47,8 @@ module ActiveRecord
                           lambda {|r| r['type_name'] =~ /^number$/i},
                           lambda {|r| r['type_name'] =~ /^real$/i},
                           lambda {|r| r['precision'] == '38'},
-                          lambda {|r| r['data_type'] == '2'}],
-        :float       => [ lambda {|r| [Jdbc::Types::FLOAT,Jdbc::Types::DOUBLE, Jdbc::Types::REAL].include?(r['data_type'].to_i)},
+                          lambda {|r| r['data_type'].to_i == Jdbc::Types::DECIMAL}],
+        :float       => [ lambda {|r| FLOAT_TYPES.include?(r['data_type'].to_i)},
                           lambda {|r| r['data_type'].to_i == Jdbc::Types::REAL}, #Prefer REAL to DOUBLE for Postgresql
                           lambda {|r| r['type_name'] =~ /^float/i},
                           lambda {|r| r['type_name'] =~ /^double$/i},
@@ -44,30 +57,34 @@ module ActiveRecord
         :datetime    => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^datetime$/i},
                           lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime.+/i},
                           lambda {|r| r['type_name'] =~ /^date/i},
                           lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
         :timestamp   => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^timestamp$/i},
-                          lambda {|r| r['type_name'] =~ /^datetime/i},
+                          lambda {|r| r['type_name'] =~ /^datetime$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime.+/i},
                           lambda {|r| r['type_name'] =~ /^date/i},
                           lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
         :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^time$/i},
-                          lambda {|r| r['type_name'] =~ /^datetime/i},  # For Informix
+                          lambda {|r| r['type_name'] =~ /^datetime$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime.+/i},  # For Informix
                           lambda {|r| r['type_name'] =~ /^date/i},
                           lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
         :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^date$/i},
                           lambda {|r| r['type_name'] =~ /^date/i},
                           lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver3
-        :binary      => [ lambda {|r| [Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB].include?(r['data_type'].to_i)},
+        :binary      => [ lambda {|r| BINARY_TYPES.include?(r['data_type'].to_i)},
                           lambda {|r| r['type_name'] =~ /^blob/i},
                           lambda {|r| r['type_name'] =~ /sub_type 0$/i}, # For FireBird
                           lambda {|r| r['type_name'] =~ /^varbinary$/i}, # We want this sucker for Mimer
                           lambda {|r| r['type_name'] =~ /^binary$/i}, ],
-        :boolean     => [ lambda {|r| [Jdbc::Types::TINYINT].include?(r['data_type'].to_i)},
+        :boolean     => [ lambda {|r| Jdbc::Types::BIT == r['data_type'].to_i && r['precision'].to_i == 1},
+                          lambda {|r| Jdbc::Types::TINYINT == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^bool/i},
-                          lambda {|r| r['data_type'] == '-7'},
+                          lambda {|r| r['data_type'].to_i == Jdbc::Types::BIT},
                           lambda {|r| r['type_name'] =~ /^tinyint$/i},
                           lambda {|r| r['type_name'] =~ /^decimal$/i},
                           lambda {|r| r['type_name'] =~ /^integer$/i}]
@@ -87,25 +104,24 @@ module ActiveRecord
           set_limit_to_nonzero_precision(type_map[k], row)
         end
 
-        AR_TO_JDBC_TYPES.keys.each do |k|
-          typerow = choose_type(k)
-          type_map[k] = { :name => typerow['type_name'].downcase }
-          case k
+        AR_TO_JDBC_TYPES.keys.each do |ar_type|
+          typerow = choose_type(ar_type)
+          type_map[ar_type] = { :name => typerow['type_name'].downcase }
+          case ar_type
           when :integer, :string, :decimal
-            set_limit_to_nonzero_precision(type_map[k], typerow)
+            set_limit_to_nonzero_precision(type_map[ar_type], typerow)
           when :boolean
-            type_map[k][:limit] = 1
+            type_map[ar_type][:limit] = 1
           end
         end
         type_map
       end
 
       def choose_type(ar_type)
-        procs = AR_TO_JDBC_TYPES[ar_type]
         types = @types
-        procs.each do |p|
+        AR_TO_JDBC_TYPES[ar_type].each do |proc|
           new_types = types.reject {|r| r["data_type"].to_i == Jdbc::Types::OTHER}
-          new_types = new_types.select(&p)
+          new_types = new_types.select(&proc)
           new_types = new_types.inject([]) do |typs,t|
             typs << t unless typs.detect {|el| el['type_name'] == t['type_name']}
             typs