kb-activerecord-jdbc-adapter 0.9.7.1-java → 1.0.0.beta1-java

data/lib/arjdbc/jdbc/adapter.rb

@@ -0,0 +1,235 @@
+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
+        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
+
+      # Locate specialized adapter specification if one exists based on config data
+      def adapter_spec(config)
+        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
+        nil
+      end
+
+      def modify_types(tp)
+        tp
+      end
+
+      def adapter_name #:nodoc:
+        'JDBC'
+      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
+
+      if ActiveRecord::VERSION::MAJOR < 3
+        # 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
+      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 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
+    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,38 @@
+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
+        @column_types ||= ::ArJdbc.constants.map{|c|
+          ::ArJdbc.const_get c }.select{ |c|
+          c.respond_to? :column_selector }.map{|c|
+          c.column_selector }.inject({}) { |h,val|
+          h[val[0]] = val[1]; h }
+      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,97 @@
+module ActiveRecord
+  module ConnectionAdapters
+    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
+      #
+      # @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)
+        @config = config.symbolize_keys!
+        @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
+        connection # force the connection to load
+        set_native_database_types
+        @stmts = {}
+      rescue Exception => e
+        raise "The driver encountered an error: #{e}"
+      end
+
+      def adapter=(adapter)
+        @adapter = adapter
+        @native_database_types = dup_native_types
+        @adapter.modify_types(@native_database_types)
+      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
+      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_jdbc
+        driver = @config[:driver].to_s
+        user   = @config[:username].to_s
+        pass   = @config[:password].to_s
+        url    = @config[:url].to_s
+
+        unless driver && url
+          raise ::ActiveRecord::ConnectionFailed, "jdbc adapter requires driver class and url"
+        end
+
+        jdbc_driver = JdbcDriver.new(driver)
+        jdbc_driver.load
+        @connection_factory = JdbcConnectionFactory.impl do
+          jdbc_driver.connection(url, user, pass)
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/connection_methods.rb

@@ -0,0 +1,16 @@
+class ActiveRecord::Base
+  class << self
+    def jdbc_connection(config)
+      adapter_class = config[:adapter_class]
+      adapter_class ||= ::ActiveRecord::ConnectionAdapters::JdbcAdapter
+      adapter_class.new(nil, logger, config)
+    end
+    alias jndi_connection jdbc_connection
+
+    def embedded_driver(config)
+      config[:username] ||= "sa"
+      config[:password] ||= ""
+      jdbc_connection(config)
+    end
+  end
+end

data/lib/arjdbc/jdbc/core_ext.rb

@@ -0,0 +1,24 @@
+module ActiveRecord # :nodoc:
+  # Represents exceptions that have propagated up through the JDBC API.
+  class JDBCError < ActiveRecordError
+    # The vendor code or error number that came from the database
+    attr_accessor :errno
+
+    # The full Java SQLException object that was raised
+    attr_accessor :sql_exception
+  end
+
+  module ConnectionAdapters     # :nodoc:
+    # Allows properly re-wrapping/re-defining methods that may already
+    # be alias_method_chain'd.
+    module ShadowCoreMethods
+      def alias_chained_method(meth, feature, target)
+        if instance_methods.include?("#{meth}_without_#{feature}")
+          alias_method "#{meth}_without_#{feature}".to_sym, target
+        else
+          alias_method meth, target if meth != target
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/discover.rb

@@ -0,0 +1,18 @@
+module ArJdbc
+  def self.discover_extensions
+    if defined?(::Gem)
+      files = Gem.find_files('arjdbc/discover')
+    else
+      files = $LOAD_PATH.map do |p|
+        discover = File.join(p, 'arjdbc','discover.rb')
+        File.exist?(p) ? discover : nil
+      end.compact
+    end
+    files.each do |f|
+      puts "Loading #{f}" if $DEBUG
+      require f
+    end
+  end
+
+  discover_extensions
+end

data/lib/arjdbc/jdbc/driver.rb

@@ -0,0 +1,44 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class JdbcDriver
+      def initialize(name)
+        @name = name
+      end
+
+      def driver_class
+        @driver_class ||= begin
+          driver_class_const = (@name[0...1].capitalize + @name[1..@name.length]).gsub(/\./, '_')
+          Jdbc::Mutex.synchronized do
+            unless Jdbc.const_defined?(driver_class_const)
+              driver_class_name = @name
+              Jdbc.module_eval do
+                include_class(driver_class_name) { driver_class_const }
+              end
+            end
+          end
+          driver_class = Jdbc.const_get(driver_class_const)
+          raise "You specify a driver for your JDBC connection" unless driver_class
+          driver_class
+        end
+      end
+
+      def load
+        Jdbc::DriverManager.registerDriver(create)
+      end
+
+      def connection(url, user, pass)
+        Jdbc::DriverManager.getConnection(url, user, pass)
+      rescue
+        # bypass DriverManager to get around problem with dynamically loaded jdbc drivers
+        props = java.util.Properties.new
+        props.setProperty("user", user)
+        props.setProperty("password", pass)
+        create.connect(url, props)
+      end
+
+      def create
+        driver_class.new
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/extension.rb

@@ -0,0 +1,47 @@
+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
+  # ActiveRecord::ConnectionAdapters::JdbcAdapter by extending an
+  # instance of it with your extension module.
+  #
+  # +name+ should be a symbol that is 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
+  #         # arjdbc/frob.rb should contain the implementation
+  #         require '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
+      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
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/java.rb

@@ -0,0 +1,14 @@
+require 'java'
+require 'arjdbc/jdbc/adapter_java'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Jdbc
+      Mutex = java.lang.Object.new
+      DriverManager = java.sql.DriverManager
+      Types = java.sql.Types
+    end
+
+    java_import "arjdbc.jdbc.JdbcConnectionFactory"
+  end
+end

data/lib/{jdbc_adapter → arjdbc/jdbc}/missing_functionality_helper.rb

@@ -1,4 +1,4 @@
-module JdbcSpec
+module ArJdbc
   module MissingFunctionalityHelper
     #Taken from SQLite adapter
 
@@ -15,7 +15,7 @@ module JdbcSpec
         move_table(altered_table_name, table_name, &caller)
       end
     end
-    
+
     def move_table(from, to, options = {}, &block) #:nodoc:
       copy_table(from, to, options, &block)
       drop_table(from)
@@ -30,7 +30,7 @@ module JdbcSpec
             (options[:rename][column.name] ||
              options[:rename][column.name.to_sym] ||
              column.name) : column.name
-          
+
           @definition.column(column_name, column.type,
             :limit => column.limit, :default => column.default,
             :null => column.null)
@@ -44,7 +44,7 @@ module JdbcSpec
         @definition.columns.map {|column| column.name},
         options[:rename] || {})
     end
-    
+
     def copy_table_indexes(from, to, rename = {}) #:nodoc:
       indexes(from).each do |index|
         name = index.name.downcase
@@ -67,7 +67,7 @@ module JdbcSpec
         end
       end
     end
-    
+
     def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
       column_mappings = Hash[*columns.map {|name| [name, name]}.flatten]
       rename.inject(column_mappings) {|map, a| map[a.last] = a.first; map}