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

data/lib/arjdbc/jdbc/adapter_require.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
-  
+
   if defined? ConnectionAdapters::ConnectionSpecification::Resolver # 4.0
     ConnectionAdapters::ConnectionSpecification::Resolver
   elsif defined? Base::ConnectionSpecification::Resolver # 3.2
@@ -7,17 +7,18 @@ module ActiveRecord
   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 
+      # 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
@@ -39,8 +40,8 @@ module ActiveRecord
       else super
       end
       super
-    end  
-  
+    end
+
   end
-  
+
 end

data/lib/arjdbc/jdbc/arel_support.rb

@@ -0,0 +1,132 @@
+module ActiveRecord::ConnectionAdapters
+  module Jdbc
+    # AREL support for the JDBC adapter.
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter
+    module ArelSupport
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def arel_visitor_name(spec)
+          if spec
+            if spec.respond_to?(:arel_visitor_name)
+              spec.arel_visitor_name # for AREL built-in visitors
+            else
+              spec.name.split('::').last.downcase # ArJdbc::PostgreSQL -> postgresql
+            end
+          else # AR::ConnnectionAdapters::MySQLAdapter => mysql
+            name.split('::').last.sub('Adapter', '').downcase
+          end
+        end
+
+        # NOTE: it's important to track our own since we might want to override
+        # what AREL setup for us e.g. we do not want `::Arel::Visitors::MSSQL`
+
+        # @private
+        RESOLVED_VISITORS = {} # lazy filled mirror of ::Arel::Visitors::VISITORS
+
+        # @todo document
+        def resolve_visitor_type(config)
+          raise "missing :adapter in #{config.inspect}" unless adapter = config[:adapter]
+
+          unless visitor_type = RESOLVED_VISITORS[ adapter ]
+            if adapter_spec = config[:adapter_spec]
+              if adapter_spec.respond_to?(:arel_visitor_type)
+                visitor_type = adapter_spec.arel_visitor_type(config)
+              elsif adapter_spec.respond_to?(:arel2_visitors) # backwards compat
+                visitor_type = adapter_spec.arel2_visitors(config).values.first
+              else # auto-convention ArJdbc::MySQL -> Arel::Visitors::MySQL
+                const_name = adapter_spec.name.split('::').last
+                visitor_type = ::Arel::Visitors.const_get(const_name) rescue nil
+              end
+            elsif respond_to?(:arel_visitor_type)
+              visitor_type = arel_visitor_type(config) # adapter_class' override
+            end
+
+            visitor_type ||= ::Arel::Visitors::VISITORS[ arel_visitor_name(adapter_spec) ]
+            visitor_type ||= ::Arel::Visitors::ToSql # default (if nothing resolved)
+
+            ::Arel::Visitors::VISITORS[ adapter ] = visitor_type
+            RESOLVED_VISITORS[ adapter ] = visitor_type
+          end
+
+          visitor_type
+        end
+
+        # @note called from `ActiveRecord::ConnectionAdapters::ConnectionPool.checkout` (up till AR-3.2)
+        # @override
+        def visitor_for(pool)
+          visitor = resolve_visitor_type(config = pool.spec.config)
+          ( prepared_statements?(config) ? visitor : bind_substitution(visitor) ).new(pool)
+        end
+
+        # @private
+        @@bind_substitutions = nil
+
+        # Generates a class for the given visitor type, this new {Class} instance
+        # is a sub-class of `Arel::Visitors::BindVisitor`.
+        # @return [Class] class for given visitor type
+        def bind_substitution(visitor)
+          # NOTE: similar convention as in AR (but no base substitution type) :
+          # class BindSubstitution < ::Arel::Visitors::ToSql
+          #   include ::Arel::Visitors::BindVisitor
+          # end
+          return const_get(:BindSubstitution) if const_defined?(:BindSubstitution)
+
+          @@bind_substitutions ||= Java::JavaUtil::HashMap.new
+          unless bind_visitor = @@bind_substitutions.get(visitor)
+            @@bind_substitutions.synchronized do
+              unless @@bind_substitutions.get(visitor)
+                bind_visitor = Class.new(visitor) do
+                  include ::Arel::Visitors::BindVisitor
+                end
+                @@bind_substitutions.put(visitor, bind_visitor)
+              end
+            end
+            bind_visitor = @@bind_substitutions.get(visitor)
+          end
+          bind_visitor
+        end
+
+        begin
+          require 'arel/visitors/bind_visitor'
+        rescue LoadError # AR-3.0
+          def bind_substitution(visitor); visitor; end
+        end
+
+      end
+
+      if defined? ::Arel::Visitors::VISITORS
+
+        # Instantiates a new AREL visitor for this adapter.
+        # @note On `ActiveRecord` **2.3** this method won't be used.
+        def new_visitor
+          visitor = self.class.resolve_visitor_type(config)
+          ( prepared_statements? ? visitor : bind_substitution(visitor) ).new(self)
+        end
+        protected :new_visitor
+
+        def bind_substitution(visitor); self.class.bind_substitution(visitor); end
+        private :bind_substitution
+
+        # @override ActiveRecord's convention
+        def unprepared_visitor
+          # super does self.class::BindSubstitution.new self
+          # we do not require the BindSubstitution constant - auto-generated :
+          visitor = self.class.resolve_visitor_type(config)
+          bind_substitution(visitor).new(self)
+        end
+
+      else # NO-OP when no AREL (AR-2.3)
+
+        # @private documented above
+        def new_visitor; end
+
+      end
+
+    end
+  end
+end

data/lib/arjdbc/jdbc/base_ext.rb

@@ -14,7 +14,7 @@ module ActiveRecord
       end
     end
   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.
@@ -23,9 +23,9 @@ module ActiveRecord
     # 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
@@ -34,19 +34,20 @@ module ActiveRecord
     def set_backtrace(backtrace)
       @raw_backtrace = backtrace
       if nested = original_exception
-        backtrace = backtrace - ( 
+        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:
+  end
+  
+  module ConnectionAdapters
     # Allows properly re-defining methods that may already be alias-chain-ed.
     # Query caching works even with overriden alias_method_chain'd methods.
+    # @private
     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,8 +1,9 @@
-module ActiveRecord
-  module ConnectionAdapters
-    
-    module JdbcConnectionPoolCallbacks
-      
+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
@@ -20,13 +21,14 @@ module ActiveRecord
       def on_checkout
         # default implementation does nothing
       end
-      
-    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?(JdbcConnectionPoolCallbacks) && connection.jndi?
+        if adapter.is_a?(ConnectionPoolCallbacks) && connection.jndi?
           adapter.extend self # extend JndiConnectionPoolCallbacks
           connection.disconnect! # disconnect initial (JNDI) connection if any
         end
@@ -40,6 +42,10 @@ module ActiveRecord
         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

@@ -1,5 +1,11 @@
 module ActiveRecord
   module ConnectionAdapters
+    # 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
       attr_writer :limit, :precision
 
@@ -21,13 +27,16 @@ module ActiveRecord
         init_column(name, default, *args)
       end
 
+      # Additional column initialization for sub-classes.
       def init_column(*args); end
 
-      # NOTE: our custom #extract_value_from_default(default)
+      # Similar to `ActiveRecord`'s `extract_value_from_default(default)`.
+      # @return default value for a given column
       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
@@ -36,7 +45,9 @@ module ActiveRecord
       end
 
       public
-      
+
+      # Returns the available column types
+      # @return [Hash] of (matcher, block) pairs
       def self.column_types
         types = {}
         for mod in ::ArJdbc.modules
@@ -47,7 +58,18 @@ module ActiveRecord
         end
         types
       end
-      
+
+      class << self
+
+        if ActiveRecord::VERSION::MAJOR > 3
+
+          # @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

@@ -1,23 +1,18 @@
 module ActiveRecord
   module ConnectionAdapters
-    # @note this class is mostly implemented in Java: *RubyJdbcConnection.java*
+    # 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
 
-      # @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
-      #
-      # @native_types - This is the default type settings sans any modifications by the
-      # individual adapter.  My guess is that if we loaded two adapters of different types
-      # then this is used as a base to be tweaked by each adapter to create @native_database_types
-
-      def initialize(config)
-        self.config = config
+      # 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
-        connection # force connection to load (@see RubyJdbcConnection.connection)
-        set_native_database_types # so we can set the native types
+        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
@@ -28,46 +23,26 @@ module ActiveRecord
         raise error
       end
 
-      attr_reader :connection_factory, :adapter, :config
-      
+      attr_reader :adapter, :config
+
+      # @deprecated no longer used (pass adapter into #initialize)
       # @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
-      
-      # Duplicate all native types into new hash structure so it can be modified
-      # without destroying original structure.
-      def dup_native_types
-        types = {}
-        @native_types.each_pair do |k, v|
-          types[k] = v.inject({}) do |memo, kv|
-            last = kv.last
-            memo[kv.first] = last.is_a?(Numeric) ? last : (last.dup rescue last)
-            memo
-          end
-        end
-        types
-      end
-      private :dup_native_types
-      
-      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
+      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; 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
@@ -86,28 +61,26 @@ module ActiveRecord
       protected
 
       def setup_jndi_factory
-        data_source = config[:data_source] || 
+        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
+        self.connection_factory = JdbcConnectionFactory.impl { data_source.connection }
       end
 
       def setup_jdbc_factory
         if ! config[:url] || ( ! config[:driver] && ! config[:driver_instance] )
           raise ::ActiveRecord::ConnectionNotEstablished, "jdbc adapter requires :driver class and :url"
         end
-        
+
         url = jdbc_url
         username = config[:username].to_s
         password = config[:password].to_s
-        jdbc_driver = ( config[:driver_instance] ||= 
+        jdbc_driver = ( config[:driver_instance] ||=
             JdbcDriver.new(config[:driver].to_s, config[:properties]) )
-        
+
         @jndi = false
-        @connection_factory = JdbcConnectionFactory.impl do
+        self.connection_factory = JdbcConnectionFactory.impl do
           jdbc_driver.connection(url, username, password)
         end
       end
@@ -123,7 +96,7 @@ module ActiveRecord
         end
         url
       end
-      
+
     end
   end
 end