c3-activerecord-jdbc-adapter 1.1.3

data/lib/arjdbc/informix/connection_methods.rb

@@ -0,0 +1,10 @@
+class ActiveRecord::Base
+  class << self
+    def informix_connection(config)
+      config[:port] ||= 9088
+      config[:url] ||= "jdbc:informix-sqli://#{config[:host]}:#{config[:port]}/#{config[:database]}:INFORMIXSERVER=#{config[:servername]}"
+      config[:driver] = 'com.informix.jdbc.IfxDriver'
+      jdbc_connection(config)
+    end
+  end
+end

data/lib/arjdbc/jdbc.rb

@@ -0,0 +1,2 @@
+require 'arjdbc/jdbc/adapter'
+require 'arjdbc/jdbc/discover'

data/lib/arjdbc/jdbc/adapter.rb

@@ -0,0 +1,283 @@
+require 'active_record/version'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'arjdbc/version'
+require 'arjdbc/jdbc/require_driver'
+require 'arjdbc/jdbc/connection_methods'
+require 'arjdbc/jdbc/compatibility'
+require 'arjdbc/jdbc/core_ext'
+require 'arjdbc/jdbc/java'
+require 'arjdbc/jdbc/type_converter'
+require 'arjdbc/jdbc/driver'
+require 'arjdbc/jdbc/column'
+require 'arjdbc/jdbc/connection'
+require 'arjdbc/jdbc/callbacks'
+require 'arjdbc/jdbc/extension'
+require 'bigdecimal'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class JdbcAdapter < AbstractAdapter
+      extend ShadowCoreMethods
+      include CompatibilityMethods if CompatibilityMethods.needed?(self)
+      include JdbcConnectionPoolCallbacks if JdbcConnectionPoolCallbacks.needed?
+
+      attr_reader :config
+
+      def initialize(connection, logger, config)
+        @config = config
+        spec = adapter_spec config
+        unless connection
+          connection_class = jdbc_connection_class spec
+          connection = connection_class.new config
+        end
+        super(connection, logger)
+        extend spec if spec
+        configure_arel2_visitors(config)
+        connection.adapter = self
+        JndiConnectionPoolCallbacks.prepare(self, connection)
+      end
+
+      def jdbc_connection_class(spec)
+        connection_class = spec.jdbc_connection_class if spec && spec.respond_to?(:jdbc_connection_class)
+        connection_class = ::ActiveRecord::ConnectionAdapters::JdbcConnection unless connection_class
+        connection_class
+      end
+
+      def jdbc_column_class
+        ActiveRecord::ConnectionAdapters::JdbcColumn
+      end
+
+      # Retrieve the raw java.sql.Connection object.
+      def jdbc_connection
+        raw_connection.connection
+      end
+
+      # Locate specialized adapter specification if one exists based on config data
+      def adapter_spec(config)
+        2.times do
+          dialect = (config[:dialect] || config[:driver]).to_s
+          ::ArJdbc.constants.map { |name| ::ArJdbc.const_get name }.each do |constant|
+            if constant.respond_to? :adapter_matcher
+              spec = constant.adapter_matcher(dialect, config)
+              return spec if spec
+            end
+          end
+
+          # If nothing matches and we're using jndi, try to automatically detect the database.
+          break unless config[:jndi] and !config[:dialect]
+          begin
+            conn = Java::javax.naming.InitialContext.new.lookup(config[:jndi]).getConnection
+            config[:dialect] = conn.getMetaData.getDatabaseProductName
+
+            # Derby-specific hack
+            if ::ArJdbc::Derby.adapter_matcher(config[:dialect], config)
+              # Needed to set the correct database schema name
+              config[:username] ||= conn.getMetaData.getUserName
+            end
+          rescue
+            conn.close if conn
+          end
+        end
+        nil
+      end
+
+      def modify_types(tp)
+        tp
+      end
+
+      def adapter_name #:nodoc:
+        'JDBC'
+      end
+
+      def arel2_visitors
+        {}
+      end
+
+      def configure_arel2_visitors(config)
+        if defined?(::Arel::Visitors::VISITORS)
+          visitors = ::Arel::Visitors::VISITORS
+          visitor = nil
+          arel2_visitors.each do |k,v|
+            visitor = v
+            visitors[k] = v
+          end
+          if visitor && config[:adapter] =~ /^(jdbc|jndi)$/
+            visitors[config[:adapter]] = visitor
+          end
+        end
+      end
+
+      def is_a?(klass)          # :nodoc:
+        # This is to fake out current_adapter? conditional logic in AR tests
+        if Class === klass && klass.name =~ /#{adapter_name}Adapter$/i
+          true
+        else
+          super
+        end
+      end
+
+      def supports_migrations?
+        true
+      end
+
+      def native_database_types #:nodoc:
+        @connection.native_database_types
+      end
+
+      def database_name #:nodoc:
+        @connection.database_name
+      end
+
+      def native_sql_to_type(tp)
+        if /^(.*?)\(([0-9]+)\)/ =~ tp
+          tname = $1
+          limit = $2.to_i
+          ntype = native_database_types
+          if ntype[:primary_key] == tp
+            return :primary_key,nil
+          else
+            ntype.each do |name,val|
+              if name == :primary_key
+                next
+              end
+              if val[:name].downcase == tname.downcase && (val[:limit].nil? || val[:limit].to_i == limit)
+                return name,limit
+              end
+            end
+          end
+        elsif /^(.*?)/ =~ tp
+          tname = $1
+          ntype = native_database_types
+          if ntype[:primary_key] == tp
+            return :primary_key,nil
+          else
+            ntype.each do |name,val|
+              if val[:name].downcase == tname.downcase && val[:limit].nil?
+                return name,nil
+              end
+            end
+          end
+        else
+          return :string,255
+        end
+        return nil,nil
+      end
+
+      def active?
+        @connection.active?
+      end
+
+      def reconnect!
+        @connection.reconnect!
+        @connection
+      end
+
+      def disconnect!
+        @connection.disconnect!
+      end
+
+      def execute(sql, name = nil)
+        if name == :skip_logging
+          _execute(sql)
+        else
+          log(sql, name) { _execute(sql) }
+        end
+      end
+
+      # we need to do it this way, to allow Rails stupid tests to always work
+      # even if we define a new execute method. Instead of mixing in a new
+      # execute, an _execute should be mixed in.
+      def _execute(sql, name = nil)
+        @connection.execute(sql)
+      end
+
+      def jdbc_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        insert_sql(sql, name, pk, id_value, sequence_name)
+      end
+
+      def jdbc_update(sql, name = nil) #:nodoc:
+        execute(sql, name)
+      end
+      def jdbc_select_all(sql, name = nil)
+        select(sql, name)
+      end
+
+      # Allow query caching to work even when we override alias_method_chain'd methods
+      alias_chained_method :select_all, :query_cache, :jdbc_select_all
+      alias_chained_method :update, :query_dirty, :jdbc_update
+      alias_chained_method :insert, :query_dirty, :jdbc_insert
+
+      # Do we need this? Not in AR 3.
+      def select_one(sql, name = nil)
+        select(sql, name).first
+      end
+
+      def select_rows(sql, name = nil)
+        rows = []
+        select(sql, name).each {|row| rows << row.values }
+        rows
+      end
+
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        id = execute(sql, name = nil)
+        id_value || id
+      end
+
+      def jdbc_columns(table_name, name = nil)
+        @connection.columns(table_name.to_s)
+      end
+      alias_chained_method :columns, :query_cache, :jdbc_columns
+
+      def tables(name = nil)
+        @connection.tables
+      end
+
+      def table_exists?(name)
+        jdbc_columns(name) rescue nil
+      end
+
+      def indexes(table_name, name = nil, schema_name = nil)
+        @connection.indexes(table_name, name, schema_name)
+      end
+
+      def begin_db_transaction
+        @connection.begin
+      end
+
+      def commit_db_transaction
+        @connection.commit
+      end
+
+      def rollback_db_transaction
+        @connection.rollback
+      end
+
+      def write_large_object(*args)
+        @connection.write_large_object(*args)
+      end
+
+      def pk_and_sequence_for(table)
+        key = primary_key(table)
+        [key, nil] if key
+      end
+
+      def primary_key(table)
+        primary_keys(table).first
+      end
+
+      def primary_keys(table)
+        @connection.primary_keys(table)
+      end
+
+      def select(*args)
+        execute(*args)
+      end
+
+      def translate_exception(e, message)
+        puts e.backtrace if $DEBUG || ENV['DEBUG']
+        super
+      end
+      protected :translate_exception
+    end
+  end
+end

data/lib/arjdbc/jdbc/callbacks.rb

@@ -0,0 +1,44 @@
+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
+          base.set_callback :checkout, :before, :on_checkout
+        else
+          base.checkin :on_checkin
+          base.checkout :on_checkout
+        end
+      end
+
+      def self.needed?
+        ActiveRecord::Base.respond_to?(:connection_pool)
+      end
+
+      def on_checkin
+        # default implementation does nothing
+      end
+
+      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
+        end
+      end
+
+      def on_checkin
+        disconnect!
+      end
+
+      def on_checkout
+        reconnect!
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/column.rb

@@ -0,0 +1,47 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class JdbcColumn < Column
+      attr_writer :limit, :precision
+
+      def initialize(config, name, default, *args)
+        call_discovered_column_callbacks(config)
+        super(name,default_value(default),*args)
+        init_column(name, default, *args)
+      end
+
+      def init_column(*args)
+      end
+
+      def default_value(val)
+        val
+      end
+
+      def self.column_types
+        # GH #25: reset the column types if the # of constants changed
+        # since last call
+        if ::ArJdbc.constants.size != driver_constants.size
+          @driver_constants = nil
+          @column_types = nil
+        end
+        @column_types ||= driver_constants.select {|c|
+          c.respond_to? :column_selector }.map {|c|
+          c.column_selector }.inject({}) {|h,val|
+          h[val[0]] = val[1]; h }
+      end
+
+      def self.driver_constants
+        @driver_constants ||= ::ArJdbc.constants.map {|c| ::ArJdbc.const_get c }
+      end
+
+      protected
+      def call_discovered_column_callbacks(config)
+        dialect = config[:dialect] || config[:driver]
+        for reg, func in JdbcColumn.column_types
+          if reg === dialect.to_s
+            func.call(config,self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/compatibility.rb

@@ -0,0 +1,51 @@
+# AR's 2.2 version of this method is sufficient, but we need it for
+# older versions
+if ActiveRecord::VERSION::MAJOR <= 2 && ActiveRecord::VERSION::MINOR < 2
+  module ActiveRecord
+    module ConnectionAdapters # :nodoc:
+      module SchemaStatements
+        # Convert the speficied column type to a SQL string.
+        def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+          if native = native_database_types[type]
+            column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup
+
+            if type == :decimal # ignore limit, use precision and scale
+              scale ||= native[:scale]
+
+              if precision ||= native[:precision]
+                if scale
+                  column_type_sql << "(#{precision},#{scale})"
+                else
+                  column_type_sql << "(#{precision})"
+                end
+              elsif scale
+                raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified"
+              end
+
+            elsif limit ||= native.is_a?(Hash) && native[:limit]
+              column_type_sql << "(#{limit})"
+            end
+
+            column_type_sql
+          else
+            type
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CompatibilityMethods
+      def self.needed?(base)
+        !base.instance_methods.include?("quote_table_name")
+      end
+
+      def quote_table_name(name)
+        quote_column_name(name)
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/connection.rb

@@ -0,0 +1,130 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class JdbcConnection
+      module ConfigHelper
+        attr_reader :config
+
+        def config=(config)
+          @config = config.symbolize_keys
+        end
+
+        def configure_connection
+          config[:retry_count] ||= 5
+          config[:connection_alive_sql] ||= "select 1"
+          @jndi_connection = false
+          @connection = nil
+          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 configure_jndi
+          jndi = config[:jndi].to_s
+          ctx = javax.naming.InitialContext.new
+          ds = ctx.lookup(jndi)
+          @connection_factory = JdbcConnectionFactory.impl do
+            ds.connection
+          end
+          unless config[:driver]
+            config[:driver] = connection.meta_data.connection.java_class.name
+          end
+          @jndi_connection = true
+        end
+
+        def configure_url
+          url = config[:url].to_s
+          if Hash === config[:options]
+            options = ''
+            config[:options].each do |k,v|
+              options << '&' unless options.empty?
+              options << "#{k}=#{v}"
+            end
+            url = url['?'] ? "#{url}&#{options}" : "#{url}?#{options}" unless options.empty?
+            config[:url] = url
+            config[:options] = nil
+          end
+          url
+        end
+
+        def configure_jdbc
+          unless config[:driver] && config[:url]
+            raise ::ActiveRecord::ConnectionNotEstablished, "jdbc adapter requires driver class and url"
+          end
+
+          driver = config[:driver].to_s
+          user   = config[:username].to_s
+          pass   = config[:password].to_s
+          url    = configure_url
+          jdbc_driver = (config[:driver_instance] ||= JdbcDriver.new(driver))
+          @connection_factory = JdbcConnectionFactory.impl do
+            jdbc_driver.connection(url, user, pass)
+          end
+        end
+      end
+
+      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
+      #
+      # @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
+        configure_connection
+        connection # force the connection to load
+        set_native_database_types
+        @stmts = {}
+      rescue ::ActiveRecord::ActiveRecordError
+        raise
+      rescue Exception => e
+        raise ::ActiveRecord::JDBCError.new("The driver encountered an unknown error: #{e}").tap { |err|
+          err.errno = 0
+          err.sql_exception = e
+        }
+      end
+
+      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|
+            memo[kv.first] = begin kv.last.dup rescue kv.last end
+            memo
+          end
+        end
+        types
+      end
+      private :dup_native_types
+
+      def jndi_connection?
+        @jndi_connection
+      end
+
+      def active?
+        @connection
+      end
+
+      private
+      include ConfigHelper
+    end
+  end
+end