activerecord-jdbc-adapter 0.9.2 → 1.1.0

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,128 @@
+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 = JdbcDriver.new(driver)
+          jdbc_driver.load
+          @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 "The driver encountered an unknown 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
+      include ConfigHelper
+    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}/jdbc.rake

@@ -15,17 +15,20 @@ def redefine_task(*args, &block)
   enhancements.each {|enhancement| redefined_task.actions << enhancement}
 end
 
+def rails_env
+  defined?(Rails.env) ? Rails.env : RAILS_ENV
+end
+
 namespace :db do
-  redefine_task :create => :environment do
-    create_database(ActiveRecord::Base.configurations[RAILS_ENV])
+  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]
+    config = ActiveRecord::Base.configurations[rails_env]
     begin
-      ActiveRecord::Base.establish_connection(config)
-      db = ActiveRecord::Base.connection.database_name
+      db = find_database_name(config)
       ActiveRecord::Base.connection.drop_database(db)
     rescue
       drop_database(config.merge('adapter' => config['adapter'].sub(/^jdbc/, '')))
@@ -34,7 +37,7 @@ namespace :db do
   task :drop => :load_config if Rake.application.lookup(:load_config)
 
   namespace :create do
-    task :all => :environment
+    task :all => :rails_env
   end
 
   namespace :drop do
@@ -46,20 +49,40 @@ namespace :db do
     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']
+        db = config['url'][/\/([^\/]*)$/, 1]
+        config['url'][/\/([^\/]*)$/, 1] = 'postgres' if db
+      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'] && url =~ /^(.*(?<!\/)\/)(?=\w)/
+        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'])
         ActiveRecord::Base.establish_connection(config)
-      rescue
+      rescue => e
+        raise e unless config['adapter'] =~ /mysql|postgresql|sqlite/
         previous_create_database(config.merge('adapter' => config['adapter'].sub(/^jdbc/, '')))
       end
     end
@@ -72,10 +95,10 @@ namespace :db do
   namespace :structure do
     redefine_task :dump => :environment do
       abcs = ActiveRecord::Base.configurations
-      ActiveRecord::Base.establish_connection(abcs[RAILS_ENV])
-      File.open("db/#{RAILS_ENV}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+      ActiveRecord::Base.establish_connection(abcs[rails_env])
+      File.open("db/#{rails_env}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
       if ActiveRecord::Base.connection.supports_migrations?
-        File.open("db/#{RAILS_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+        File.open("db/#{rails_env}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
       end
     end
   end
@@ -86,7 +109,7 @@ namespace :db do
       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|
+      IO.readlines("db/#{rails_env}_structure.sql").join.split(";\n\n").each do |ddl|
         begin
           ActiveRecord::Base.connection.execute(ddl.chomp(';'))
         rescue Exception => ex
@@ -97,20 +120,7 @@ namespace :db do
 
     redefine_task :purge => :environment do
       abcs = ActiveRecord::Base.configurations
-      config = abcs['test'].dup
-      if config['adapter'] =~ /postgresql/i
-        if config['url']
-          db = config['url'][/\/([^\/]*)$/, 1]
-          config['url'][/\/([^\/]*)$/, 1] = 'postgres' if db
-        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 = find_database_name(abcs['test'])
       ActiveRecord::Base.connection.recreate_database(db)
     end
   end