activerecord-jdbc-alt-adapter 50.3.0-java

data/lib/arjdbc/jdbc/adapter_require.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+
+  if defined? ConnectionAdapters::ConnectionSpecification::Resolver # 4.0
+    ConnectionAdapters::ConnectionSpecification::Resolver
+  elsif defined? Base::ConnectionSpecification::Resolver # 3.2
+    Base::ConnectionSpecification::Resolver
+  else class << Base; self; end # 2.3, 3.0, 3.1 :
+    # def self.establish_connection ... on ActiveRecord::Base
+  end.class_eval do
+
+    # @private
+    def require(path)
+      # NOTE: we're inspecting resolver.spec connection resolution which does :
+      # `require "active_record/connection_adapters/#{spec[:adapter]}_adapter"`
+      # ...
+      # this {#require} method is only re-defined on a Resolver object and thus
+      # will not hurt performance - it will only be called for a few times (most
+      # likely once), this should still be fine for AR < 3.2 where this patch
+      # ends up on `class << ActiveRecord::Base` since models usually rely on
+      # Rails's auto-loading of (missing) constants and rarely use `require`.
+      #
+      # other alternative (to make sure we do not need to eager load AR built-in
+      #  adapters) would be to mingle with the $LOAD_PATH which seems worse ...
+      case path
+      when 'active_record/connection_adapters/mysql_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/mysql_adapter.rb'
+        super('arjdbc/mysql')
+      when 'active_record/connection_adapters/mysql2_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/mysql2_adapter.rb'
+        super('arjdbc/mysql')
+      when 'active_record/connection_adapters/postgresql_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/postgresql_adapter.rb'
+        super('arjdbc/postgresql')
+      when 'active_record/connection_adapters/sqlite_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/sqlite_adapter.rb'
+        super('arjdbc/sqlite3')
+      when 'active_record/connection_adapters/sqlite3_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/sqlite3_adapter.rb'
+        super('arjdbc/sqlite3')
+      else super
+      end
+    end
+
+  end
+
+end

data/lib/arjdbc/jdbc/base_ext.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  class << Base
+    m = Module.new do
+      # Allow adapters to provide their own {#reset_column_information} method.
+      # @note This only affects the current thread's connection.
+      def reset_column_information # :nodoc:
+        # invoke the adapter-specific reset_column_information method
+        connection.reset_column_information if connection.respond_to?(:reset_column_information)
+        super
+      end
+    end
+
+    self.prepend(m)
+  end
+end

data/lib/arjdbc/jdbc/callbacks.rb

@@ -0,0 +1,53 @@
+module ActiveRecord::ConnectionAdapters
+  module Jdbc
+    # ActiveRecord connection pool callbacks for JDBC.
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::JndiConnectionPoolCallbacks
+    module ConnectionPoolCallbacks
+
+      def self.included(base)
+        base.set_callback :checkin, :after, :on_checkin
+        base.set_callback :checkout, :before, :on_checkout
+        base.class_eval do
+          def self.new(*args)
+            adapter = super # extend with JndiConnectionPoolCallbacks if a JNDI connection :
+            Jdbc::JndiConnectionPoolCallbacks.prepare(adapter, adapter.instance_variable_get(:@connection))
+            adapter
+          end
+        end
+      end
+
+      def on_checkin
+        # default implementation does nothing
+      end
+
+      def on_checkout
+        # default implementation does nothing
+      end
+
+    end
+    # JNDI specific connection pool callbacks that make sure the JNDI connection
+    # is disconnected on check-in and looked up (re-connected) on-checkout.
+    module JndiConnectionPoolCallbacks
+
+      def self.prepare(adapter, connection)
+        if adapter.is_a?(ConnectionPoolCallbacks) && connection.jndi?
+          adapter.extend self # extend JndiConnectionPoolCallbacks
+          connection.disconnect! # if connection.open? - close initial (JNDI) connection
+        end
+      end
+
+      def on_checkin
+        disconnect!
+      end
+
+      def on_checkout
+        reconnect!
+      end
+    end
+
+  end
+  # @deprecated use {ActiveRecord::ConnectionAdapters::Jdbc::ConnectionPoolCallbacks}
+  JdbcConnectionPoolCallbacks = Jdbc::ConnectionPoolCallbacks
+  # @deprecated use {ActiveRecord::ConnectionAdapters::Jdbc::JndiConnectionPoolCallbacks}
+  JndiConnectionPoolCallbacks = Jdbc::JndiConnectionPoolCallbacks
+end

data/lib/arjdbc/jdbc/column.rb

@@ -0,0 +1,97 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Jdbc
+      autoload :TypeCast, 'arjdbc/jdbc/type_cast'
+    end
+    # The base class for all of {JdbcAdapter}'s returned columns.
+    # Instances of {JdbcColumn} will get extended with "column-spec" modules
+    # (similar to how {JdbcAdapter} gets spec modules in) if the adapter spec
+    # module provided a `column_selector` (matcher) method for it's database
+    # specific type.
+    # @see JdbcAdapter#jdbc_column_class
+    class JdbcColumn < Column
+      # @deprecated attribute writers will be removed in 1.4
+      attr_writer :limit, :precision # unless ArJdbc::AR42
+
+      def initialize(config, name, *args)
+        if self.class == JdbcColumn
+          # NOTE: extending classes do not want this if they do they shall call
+          call_discovered_column_callbacks(config) if config
+          default = args.shift
+        else # for extending classes allow ignoring first argument :
+          if ! config.nil? && ! config.is_a?(Hash)
+            default = name; name = config # initialize(name, default, *args)
+          else
+            default = args.shift
+          end
+        end
+
+        if ArJdbc::AR50
+          default = args[0].cast(default)
+
+          sql_type = args.delete_at(1)
+          type = args.delete_at(0)
+
+          args.unshift(SqlTypeMetadata.new(:sql_type => sql_type, :type => type))
+        elsif ArJdbc::AR42
+          default = args[0].type_cast_from_database(default)
+        else
+          default = default_value(default)
+        end
+
+        # super <= 4.1: (name, default, sql_type = nil, null = true)
+        # super >= 4.2: (name, default, cast_type, sql_type = nil, null = true)
+        # super >= 5.0: (name, default, sql_type_metadata = nil, null = true)
+        
+        super(name, default, *args)
+        init_column(name, default, *args)
+      end
+
+      # Additional column initialization for sub-classes.
+      def init_column(*args); end
+
+      # Similar to `ActiveRecord`'s `extract_value_from_default(default)`.
+      # @return default value for a column (possibly extracted from driver value)
+      def default_value(value); value; end
+
+      protected
+
+      # @private
+      def call_discovered_column_callbacks(config)
+        dialect = (config[:dialect] || config[:driver]).to_s
+        for matcher, block in self.class.column_types
+          block.call(config, self) if matcher === dialect
+        end
+      end
+
+      public
+
+      # Returns the available column types
+      # @return [Hash] of (matcher, block) pairs
+      def self.column_types
+        types = {}
+        for mod in ::ArJdbc.modules
+          if mod.respond_to?(:column_selector)
+            sel = mod.column_selector # [ matcher, block ]
+            types[ sel[0] ] = sel[1]
+          end
+        end
+        types
+      end
+
+      class << self
+
+        include Jdbc::TypeCast if ::ActiveRecord::VERSION::STRING >= '4.2'
+
+        if ActiveRecord::VERSION::MAJOR > 3 && ActiveRecord::VERSION::STRING < '4.2'
+
+          # @private provides compatibility between AR 3.x/4.0 API
+          def string_to_date(value); value_to_date(value) end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/arjdbc/jdbc/connection.rb

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # JDBC (connection) base class, custom adapters we support likely extend
+    # this class. For maximum performance most of this class and the sub-classes
+    # we ship are implemented in Java, check: *RubyJdbcConnection.java*
+    class JdbcConnection
+
+      def native_database_types
+        JdbcTypeConverter.new(supported_data_types).choose_best_types
+      end
+
+    end
+  end
+end

data/lib/arjdbc/jdbc/connection_methods.rb

@@ -0,0 +1,37 @@
+module ArJdbc
+  ConnectionMethods = ::ActiveRecord::ConnectionHandling
+
+  ConnectionMethods.module_eval do
+
+    def jdbc_connection(config)
+      adapter_class = config[:adapter_class] || ::ActiveRecord::ConnectionAdapters::JdbcAdapter
+      adapter_class.new(nil, logger, nil, config)
+    end
+
+    def jndi_connection(config); jdbc_connection(config) end
+
+    def embedded_driver(config)
+      config[:username] ||= "sa"
+      config[:password] ||= ""
+      jdbc_connection(config)
+    end
+
+    private
+
+    def jndi_config?(config)
+      ::ActiveRecord::ConnectionAdapters::JdbcConnection.jndi_config?(config)
+    end
+
+    # @note keeps the same Hash when possible - helps caching on native side
+    def symbolize_keys_if_necessary(hash)
+      symbolize = false
+      hash.each_key do |key|
+        if ! key.is_a?(Symbol) && key.respond_to?(:to_sym)
+          symbolize = true; break
+        end
+      end
+      symbolize ? hash.symbolize_keys : hash
+    end
+
+  end
+end

data/lib/arjdbc/jdbc/error.rb

@@ -0,0 +1,65 @@
+module ActiveRecord
+  # Represents exceptions that have propagated up through the JDBC API.
+  class JDBCError < WrappedDatabaseException
+
+    def initialize(message = nil, cause = $!)
+      super( ( message.nil? && cause ) ? cause.message : message, nil )
+      if cause.is_a? Java::JavaSql::SQLException
+        @jdbc_exception, @cause = cause, nil
+      else
+        @cause, @jdbc_exception = cause, nil
+      end
+    end
+
+    # The DB (or JDBC driver implementation specific) vendor error code.
+    # @see #jdbc_exception
+    # @return [Integer, NilClass]
+    def error_code
+      if ( @error_code ||= nil ).nil?
+        @error_code = jdbc_exception ? jdbc_exception.getErrorCode : nil
+      else
+        @error_code
+      end
+    end
+    # @deprecated
+    # @see #error_code
+    def errno; error_code end
+
+    # SQL code as standardized by ISO/ANSI and Open Group (X/Open), although
+    # some codes have been reserved for DB vendors to define for themselves.
+    # @see #jdbc_exception
+    # @return [String, NilClass]
+    def sql_state; jdbc_exception ? jdbc_exception.getSQLState : nil end
+
+    # The full Java exception (SQLException) object that was raised (if any).
+    # @note Navigate through chained exceptions using `jdbc_exception.next_exception`.
+    def jdbc_exception; @jdbc_exception end
+    alias_method :sql_exception, :jdbc_exception
+
+    # true if the current error might be recovered e.g. by re-trying the transaction
+    def recoverable?; jdbc_exception.is_a?(Java::JavaSql::SQLRecoverableException) end
+    # true when a failed operation might be able to succeed when retried (e.g. timeouts)
+    def transient?; jdbc_exception.is_a?(Java::JavaSql::SQLTransientException) end
+
+    # Likely (but not necessarily) the same as {#jdbc_exception}.
+    def cause; ( @cause ||= nil ) || jdbc_exception end
+    # @override
+    # @private for correct super-class (StatementInvalid) compatibility
+    alias_method :original_exception, :cause
+
+    # @override
+    def set_backtrace(backtrace)
+      @raw_backtrace = backtrace
+      if ( nested = cause ) && ! nested.equal?(self)
+        backtrace = backtrace - ( nested.respond_to?(:raw_backtrace) ? nested.raw_backtrace : nested.backtrace )
+        backtrace << "#{nested.backtrace.first}: #{nested.message} (#{nested.class.name})"
+        backtrace.concat nested.backtrace[1..-1] || []
+      end
+      super(backtrace)
+    end
+
+    # @private
+    def raw_backtrace; @raw_backtrace ||= backtrace end
+
+  end
+end

data/lib/arjdbc/jdbc/extension.rb

@@ -0,0 +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 JdbcAdapter by
+  # extending an instance of it with your extension 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
+  #
+  # Example:
+  #
+  #   ArJdbc.extension :FRoB do |name|
+  #     if name =~ /frob/i
+  #       require 'arjdbc/frob' # contains ArJdbc::FRoB
+  #       true
+  #     end
+  #   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
+      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

@@ -0,0 +1,13 @@
+require 'java'
+require 'arjdbc/jdbc/adapter_java'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Jdbc
+      # @private
+      DriverManager = ::Java::JavaSql::DriverManager
+      # @private
+      Types = ::Java::JavaSql::Types
+    end
+  end
+end

data/lib/arjdbc/jdbc/railtie.rb

@@ -0,0 +1,2 @@
+require 'arjdbc/railtie'
+ArJdbc.deprecate "require 'arjdbc/railtie' instead of 'arjdbc/jdbc/railtie'"

data/lib/arjdbc/jdbc/rake_tasks.rb

@@ -0,0 +1,3 @@
+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