activerecord-jdbc-adapter-onsite 1.2.2

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,134 @@
+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] = if kv.last.is_a? Numeric
+                               kv.last
+                             else
+                               begin kv.last.dup rescue kv.last end
+                             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) && ::Gem.respond_to?(:find_files)
+      files = ::Gem.find_files('arjdbc/discover')
+    else
+      files = $LOAD_PATH.map do |p|
+        discover = File.join(p, 'arjdbc','discover.rb')
+        File.exist?(discover) ? 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,35 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class JdbcDriver
+      def initialize(name)
+        @name = name
+        @driver = driver_class.new
+      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
+                java_import(driver_class_name) { driver_class_const }
+              end
+            end
+          end
+          driver_class = Jdbc.const_get(driver_class_const)
+          raise "You must specify a driver for your JDBC connection" unless driver_class
+          driver_class
+        end
+      end
+
+      def connection(url, user, pass)
+        # bypass DriverManager to get around problem with dynamically loaded jdbc drivers
+        props = java.util.Properties.new
+        props.setProperty("user", user)
+        props.setProperty("password", pass)
+        @driver.connect(url, props)
+      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/arjdbc/jdbc/jdbc.rake

@@ -0,0 +1,131 @@
+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}
+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'])
+        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])
+      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 }
+      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)
+    end
+  end
+end