activerecord-jdbc-adapter 1.3.0.beta1 → 1.3.0.beta2

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
+  
+    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
+      super
+    end  
+  
+  end
+  
+end

data/lib/arjdbc/jdbc/base_ext.rb

@@ -4,7 +4,7 @@ module ActiveRecord
     class << self
       # Allow adapters to provide their own {#reset_column_information} method.
       # @note This only affects the current thread's connection.
-      def reset_column_information_with_arjdbc
+      def reset_column_information_with_arjdbc # :nodoc:
         # invoke the adapter-specific reset_column_information method
         connection.reset_column_information if connection.respond_to?(:reset_column_information)
         reset_column_information_without_arjdbc
@@ -17,14 +17,36 @@ module ActiveRecord
   
   # Represents exceptions that have propagated up through the JDBC API.
   class JDBCError < ActiveRecordError
-    # The vendor code or error number that came from the database
+    # 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
 
   module ConnectionAdapters # :nodoc:
-    # Allows properly re-defining methods that may already be alias_method_chain'd.
+    # Allows properly re-defining methods that may already be alias-chain-ed.
+    # Query caching works even with overriden alias_method_chain'd methods.
     module ShadowCoreMethods
       def alias_chained_method(name, feature, target)
         # NOTE: aliasing for things such as columns (with feature query_cache)

data/lib/arjdbc/jdbc/callbacks.rb

@@ -1,6 +1,8 @@
 module ActiveRecord
   module ConnectionAdapters
+    
     module JdbcConnectionPoolCallbacks
+      
       def self.included(base)
         if base.respond_to?(:set_callback) # Rails 3 callbacks
           base.set_callback :checkin, :after, :on_checkin
@@ -11,10 +13,6 @@ module ActiveRecord
         end
       end
 
-      def self.needed?
-        ActiveRecord::Base.respond_to?(:connection_pool)
-      end
-
       def on_checkin
         # default implementation does nothing
       end
@@ -22,13 +20,15 @@ module ActiveRecord
       def on_checkout
         # default implementation does nothing
       end
+      
     end
 
     module JndiConnectionPoolCallbacks
-      def self.prepare(adapter, conn)
-        if ActiveRecord::Base.respond_to?(:connection_pool) && conn.jndi_connection?
-          adapter.extend self
-          conn.disconnect! # disconnect initial connection in JdbcConnection#initialize
+      
+      def self.prepare(adapter, connection)
+        if adapter.is_a?(JdbcConnectionPoolCallbacks) && connection.jndi?
+          adapter.extend self # extend JndiConnectionPoolCallbacks
+          connection.disconnect! # disconnect initial (JNDI) connection if any
         end
       end
 
@@ -40,5 +40,6 @@ module ActiveRecord
         reconnect!
       end
     end
+    
   end
 end

data/lib/arjdbc/jdbc/column.rb

@@ -36,28 +36,16 @@ module ActiveRecord
       end
 
       public
-
+      
       def self.column_types
-        # reset the column types if the # of constants changed since last call
-        @column_types ||= begin 
-          types = driver_constants.select { |c| c.respond_to? :column_selector }
-          types.map! { |c| c.column_selector }
-          types.inject({}) { |h, val| h[ val[0] ] = val[1]; h }
+        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
-      end
-
-      def self.driver_constants
-        reset_constants
-        @driver_constants ||= ::ArJdbc.constants.map { |c| ::ArJdbc.const_get c }
-      end
-
-      def self.reset_constants!
-        @driver_constants = nil; @column_types = nil
-      end
-      
-      def self.reset_constants
-        return false if ! defined?(@driver_constants) || ! @driver_constants
-        reset_constants! if ::ArJdbc.constants.size != @driver_constants.size
+        types
       end
       
     end

data/lib/arjdbc/jdbc/connection.rb

@@ -1,9 +1,8 @@
 module ActiveRecord
   module ConnectionAdapters
+    # @note this class is mostly implemented in Java: *RubyJdbcConnection.java*
     class JdbcConnection
 
-      attr_reader :adapter, :connection_factory
-
       # @native_database_types - setup properly by adapter= versus set_native_database_types.
       #   This contains type information for the adapter.  Individual adapters can make tweaks
       #   by defined modify_types
@@ -14,12 +13,11 @@ module ActiveRecord
 
       def initialize(config)
         self.config = config
-        @connection = nil
-        @jndi_connection = false
-        configure_connection # ConfigHelper#configure_connection
-        connection # force the connection to load (@see RubyJDbcConnection.connection)
-        set_native_database_types
-        @stmts = {} # AR compatibility - statement cache not used
+        @connection = nil; @jndi = nil
+        # @stmts = {} # AR compatibility - statement cache not used
+        setup_connection_factory
+        connection # force connection to load (@see RubyJdbcConnection.connection)
+        set_native_database_types # so we can set the native types
       rescue Java::JavaSql::SQLException => e
         e = e.cause if defined?(NativeException) && e.is_a?(NativeException) # JRuby-1.6.8
         error = e.getMessage || e.getSQLState
@@ -30,22 +28,15 @@ module ActiveRecord
         raise error
       end
 
-      def jndi_connection?
-        @jndi_connection == true
-      end
-
-      def active?
-        !! @connection
-      end
+      attr_reader :connection_factory, :adapter, :config
       
+      # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#initialize
       def adapter=(adapter)
         @adapter = adapter
         @native_database_types = dup_native_types
         @adapter.modify_types(@native_database_types)
         @adapter.config.replace(config)
       end
-
-      private
       
       # Duplicate all native types into new hash structure so it can be modified
       # without destroying original structure.
@@ -60,80 +51,78 @@ module ActiveRecord
         end
         types
       end
+      private :dup_native_types
       
-      module ConfigHelper
-        
-        attr_reader :config
-
-        def config=(config)
-          @config = config.symbolize_keys
-        end
-
-        # Configure this connection from the available configuration.
-        # @see #configure_jdbc
-        # @see #configure_jndi
-        # 
-        # @note this has nothing to do with the configure_connection implemented
-        # on some of the concrete adapters (e.g. {#ArJdbc::Postgres})
-        def configure_connection
-          config[:retry_count] ||= 5
-          config[:connection_alive_sql] ||= "select 1"
-          if config[:jndi]
-            begin
-              configure_jndi
-            rescue => e
-              warn "JNDI data source unavailable: #{e.message}; trying straight JDBC"
-              configure_jdbc
-            end
-          else
-            configure_jdbc
-          end
-        end
+      def config=(config)
+        @config = config.symbolize_keys
+        # NOTE: JDBC 4.0 drivers support checking if connection isValid
+        # thus no need to @config[:connection_alive_sql] ||= 'SELECT 1'
+        @config[:retry_count] ||= 5
+        @config
+      end
+      
+      def jndi?; @jndi; end
+      alias_method :jndi_connection?, :jndi?
 
-        def configure_jndi
-          data_source = javax.naming.InitialContext.new.lookup config[:jndi].to_s
-          @jndi_connection = true
-          @connection_factory = JdbcConnectionFactory.impl do
-            data_source.connection
+      # 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 config[:jndi] || config[:data_source]
+          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
 
-        def configure_jdbc
-          if ! config[:url] || ( ! config[:driver] && ! config[:driver_instance] )
-            raise ::ActiveRecord::ConnectionNotEstablished, "jdbc adapter requires :driver class and :url"
-          end
-
-          url = configure_url
-          username = config[:username].to_s
-          password = config[:password].to_s
-          jdbc_driver = ( config[:driver_instance] ||= 
-              JdbcDriver.new(config[:driver].to_s, config[:properties]) )
+      protected
 
-          @connection_factory = JdbcConnectionFactory.impl do
-            jdbc_driver.connection(url, username, password)
-          end
+      def setup_jndi_factory
+        data_source = config[:data_source] || 
+          Java::JavaxNaming::InitialContext.new.lookup(config[:jndi].to_s)
+        
+        @jndi = true
+        @connection_factory = JdbcConnectionFactory.impl do
+          data_source.connection
         end
+      end
 
-        private
+      def setup_jdbc_factory
+        if ! config[:url] || ( ! config[:driver] && ! config[:driver_instance] )
+          raise ::ActiveRecord::ConnectionNotEstablished, "jdbc adapter requires :driver class and :url"
+        end
         
-        def configure_url
-          url = config[:url].to_s
-          if Hash === config[:options]
-            options = ''
-            config[:options].each do |key, val|
-              options << '&' unless options.empty?
-              options << "#{key}=#{val}"
-            end
-            url = url['?'] ? "#{url}&#{options}" : "#{url}?#{options}" unless options.empty?
-            config[:url] = url
-            config[:options] = nil
-          end
-          url
+        url = jdbc_url
+        username = config[:username].to_s
+        password = config[:password].to_s
+        jdbc_driver = ( config[:driver_instance] ||= 
+            JdbcDriver.new(config[:driver].to_s, config[:properties]) )
+        
+        @jndi = false
+        @connection_factory = JdbcConnectionFactory.impl do
+          jdbc_driver.connection(url, username, password)
         end
+      end
 
-      end # ConfigHelper
-      
-      include ConfigHelper
+      private
+
+      def jdbc_url
+        url = config[:url].to_s
+        if Hash === config[:options]
+          options = config[:options].map { |key, val| "#{key}=#{val}" }.join('&')
+          url = url['?'] ? "#{url}&#{options}" : "#{url}?#{options}" unless options.empty?
+          config[:url] = url; config[:options] = nil
+        end
+        url
+      end
       
     end
   end

data/lib/arjdbc/jdbc/extension.rb

@@ -30,16 +30,14 @@ module ArJdbc
       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
+    end unless mod.respond_to?(:adapter_matcher)
   end
   
   private

data/lib/arjdbc/jdbc/jdbc.rake

@@ -1,141 +1,3 @@
-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} unless enhancements.nil?
-end
-
-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']
-        url = config['url'].dup
-        db = url[/\/([^\/]*)$/, 1]
-        if db
-          url[/\/([^\/]*)$/, 1] = 'postgres'
-          config['url'] = url
-        end
-      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'] and url =~ /^(.*(?<!\/)\/)(?=\w)/
-          url = $1
-        end
-
-        ActiveRecord::Base.establish_connection(config.merge({'database' => nil, 'url' => url}))
-        ActiveRecord::Base.connection.create_database(config['database'], config)
-        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])
-      filename = ENV['DB_STRUCTURE'] || "db/#{rails_env}_structure.sql"
-      File.open(filename, "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
-      if ActiveRecord::Base.connection.supports_migrations?
-        File.open(filename, "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
-      end
-    end
-
-    redefine_task :load => :environment do
-      abcs = ActiveRecord::Base.configurations
-      ActiveRecord::Base.establish_connection(abcs[rails_env])
-      filename = ENV['DB_STRUCTURE'] || "db/#{rails_env}_structure.sql"
-      IO.read(filename).split(/;\n*/m).each do |ddl|
-        ActiveRecord::Base.connection.execute(ddl)
-      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, abcs['test'])
-    end
-  end
-end
+# @deprecated
+warn "[DEPRECATED] load 'arjdbc/tasks.rb' (or 'arjdbc/tasks/database.rake') instead of 'arjdbc/jdbc/jdbc.rake'"
+load 'arjdbc/tasks.rb'