neo-activerecord-jdbc-adapter 5.0.pre2

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,44 @@
+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
+
+  # Represents exceptions that have propagated up through the JDBC API.
+  class JDBCError < ActiveRecordError
+    # The vendor code or error number that came from the database.
+    # @note writer being used by the Java API
+    attr_accessor :errno
+    # The full Java SQLException object that was raised.
+    # @note writer being used by the Java API
+    attr_accessor :sql_exception
+
+    attr_reader :original_exception, :raw_backtrace
+
+    def initialize(message = nil, original_exception = nil) # $!
+      super(message)
+      @original_exception = original_exception
+    end
+
+    def set_backtrace(backtrace)
+      @raw_backtrace = backtrace
+      if nested = original_exception
+        backtrace = backtrace - (
+          nested.respond_to?(:raw_backtrace) ? nested.raw_backtrace : nested.backtrace )
+        backtrace << "#{nested.backtrace.first}: #{nested.message} (#{nested.class.name})"
+        backtrace += nested.backtrace[1..-1] || []
+      end
+      super(backtrace)
+    end
+
+  end
+end

data/lib/arjdbc/jdbc/callbacks.rb

@@ -0,0 +1,51 @@
+module ActiveRecord::ConnectionAdapters
+  module Jdbc
+    # ActiveRecord connection pool callbacks for JDBC.
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::JndiConnectionPoolCallbacks
+    module ConnectionPoolCallbacks
+
+      def self.included(base)
+        if base.respond_to?(:set_callback) # Rails 3 callbacks
+          base.set_callback :checkin, :after, :on_checkin
+          base.set_callback :checkout, :before, :on_checkout
+        else
+          base.checkin :on_checkin
+          base.checkout :on_checkout
+        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! # disconnect initial (JNDI) connection if any
+        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,133 @@
+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
+
+      # Initializer implemented in Ruby.
+      # @note second argument is mandatory, only optional for compatibility
+      def initialize(config, adapter = nil)
+        @config = config; @adapter = adapter
+        @connection = nil; @jndi = nil
+        # @stmts = {} # AR compatibility - statement cache not used
+        setup_connection_factory
+        init_connection # @see RubyJdbcConnection.init_connection
+      rescue Java::JavaSql::SQLException => e
+        e = e.cause if defined?(NativeException) && e.is_a?(NativeException) # JRuby-1.6.8
+        error = e.getMessage || e.getSQLState
+        error = error ? "#{e.java_class.name}: #{error}" : e.java_class.name
+        error = ::ActiveRecord::JDBCError.new("The driver encountered an unknown error: #{error}")
+        error.errno = e.getErrorCode
+        error.sql_exception = e
+        raise error
+      end
+
+      attr_reader :adapter, :config
+
+      # @deprecated no longer used (pass adapter into #initialize)
+      # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#initialize
+      def adapter=(adapter); @adapter = adapter; end
+
+      def native_database_types
+        JdbcTypeConverter.new(supported_data_types).choose_best_types
+      end
+
+      # @deprecated no longer used - only kept for compatibility
+      def set_native_database_types
+        ArJdbc.deprecate "set_native_database_types is no longer used and does nothing override native_database_types instead"
+      end
+
+      def jndi?; @jndi; end
+      alias_method :jndi_connection?, :jndi?
+
+      # Sets the connection factory from the available configuration.
+      # @see #setup_jdbc_factory
+      # @see #setup_jndi_factory
+      #
+      # @note this has nothing to do with the configure_connection implemented
+      # on some of the concrete adapters (e.g. {#ArJdbc::Postgres})
+      def setup_connection_factory
+        if self.class.jndi_config?(config)
+          begin
+            setup_jndi_factory
+          rescue => e
+            warn "JNDI data source unavailable: #{e.message}; trying straight JDBC"
+            setup_jdbc_factory
+          end
+        else
+          setup_jdbc_factory
+        end
+      end
+
+      protected
+
+      def setup_jndi_factory
+        data_source = config[:data_source] ||
+          Java::JavaxNaming::InitialContext.new.lookup(config[:jndi].to_s)
+
+        @jndi = true
+        self.connection_factory = JndiConnectionFactoryImpl.new(data_source)
+      end
+
+      # @private
+      class JndiConnectionFactoryImpl
+        include JdbcConnectionFactory
+
+        def initialize(data_source)
+          @data_source = data_source
+        end
+
+        def newConnection
+          @data_source.connection
+        end
+      end
+
+      def setup_jdbc_factory
+        if ! config[:url] || ( ! config[:driver] && ! config[:driver_instance] )
+          msg = config[:url] ? ":url = #{config[:url]}" : ":driver = #{config[:driver]}"
+          raise ::ActiveRecord::ConnectionNotEstablished, "jdbc adapter requires :driver and :url (got #{msg})"
+        end
+
+        url = jdbc_url
+        username = config[:username]
+        password = config[:password]
+        driver = ( config[:driver_instance] ||=
+            JdbcDriver.new(config[:driver].to_s, config[:properties]) )
+
+        @jndi = false
+        self.connection_factory = JdbcConnectionFactoryImpl.new(url, username, password, driver)
+      end
+
+      # @private
+      class JdbcConnectionFactoryImpl
+        include JdbcConnectionFactory
+
+        def initialize(url, username, password, driver)
+          @url = url
+          @username = username
+          @password = password
+          @driver = driver
+        end
+
+        def newConnection
+          @driver.connection(@url, @username, @password)
+        end
+      end
+
+      private
+
+      def jdbc_url
+        url = config[:url].to_s
+        if options = config[:options]
+          ArJdbc.deprecate "use config[:properties] to specify connection URL properties instead of config[:options]"
+          options = options.map { |key, val| "#{key}=#{val}" }.join('&') if Hash === options
+          url = url['?'] ? "#{url}&#{options}" : "#{url}?#{options}" unless options.empty?
+          config[:url] = url; config[:options] = nil
+        end
+        url
+      end
+
+    end
+  end
+end

data/lib/arjdbc/jdbc/connection_methods.rb

@@ -0,0 +1,36 @@
+module ArJdbc
+  if ActiveRecord.const_defined? :ConnectionHandling # 4.0
+    ConnectionMethods = ActiveRecord::ConnectionHandling
+  else # 3.x
+    ConnectionMethods = (class << ActiveRecord::Base; self; end)
+  end
+  ConnectionMethods.module_eval do
+
+    def jdbc_connection(config)
+      adapter_class = config[:adapter_class]
+      adapter_class ||= ::ActiveRecord::ConnectionAdapters::JdbcAdapter
+
+      # Once all adapters converted to AR5 then this rescue can be removed
+      begin
+        adapter_class.new(nil, logger, nil, config)
+      rescue ArgumentError
+        adapter_class.new(nil, logger, config)
+      end
+    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
+
+  end
+end

data/lib/arjdbc/jdbc/driver.rb

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class JdbcDriver
+      attr_reader :name, :properties
+
+      def initialize(name, properties = {})
+        @name = name
+        @driver = driver_class.new
+        if properties.is_a?(Java::JavaUtil::Properties)
+          @properties = properties # allow programmatically set properties
+        else
+          @properties = Java::JavaUtil::Properties.new
+          properties.each { |key, val| @properties[key.to_s] = val.to_s } if properties
+        end
+      end
+
+      def driver_class
+        @driver_class ||= begin
+          driver_class_const = (@name[0...1].capitalize + @name[1..@name.length]).gsub(/\./, '_')
+          Jdbc::DriverManager.java_class.synchronized do # avoid 2 threads here
+            unless Jdbc.const_defined?(driver_class_const)
+              driver_class_name = @name
+              Jdbc.module_eval do
+                java_import(driver_class_name) { driver_class_const }
+              end
+            end
+          end unless Jdbc.const_defined?(driver_class_const)
+          driver_class = Jdbc.const_get(driver_class_const)
+          raise "You must specify a driver for your JDBC connection" unless driver_class
+          driver_class
+        end
+      end
+
+      def connection(url, user, pass)
+        # bypass DriverManager to get around problem with dynamically loaded jdbc drivers
+        properties = self.properties.clone
+        properties.setProperty("user", user.to_s) if user
+        properties.setProperty("password", pass.to_s) if pass
+        @driver.connect(url, properties)
+      end
+    end
+  end
+end