c3-activerecord-jdbc-adapter 1.1.3

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

data/lib/arjdbc/jdbc/missing_functionality_helper.rb

@@ -0,0 +1,87 @@
+module ArJdbc
+  module MissingFunctionalityHelper
+    #Taken from SQLite adapter
+
+    def alter_table(table_name, options = {}) #:nodoc:
+      table_name = table_name.to_s.downcase
+      altered_table_name = "altered_#{table_name}"
+      caller = lambda {|definition| yield definition if block_given?}
+
+      transaction do
+        # A temporary table might improve performance here, but
+        # it doesn't seem to maintain indices across the whole move.
+        move_table(table_name, altered_table_name,
+          options)
+        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)
+    end
+
+    def copy_table(from, to, options = {}) #:nodoc:
+      options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
+      create_table(to, options) do |definition|
+        @definition = definition
+        columns(from).each do |column|
+          column_name = options[:rename] ?
+            (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)
+        end
+        @definition.primary_key(primary_key(from)) if primary_key(from)
+        yield @definition if block_given?
+      end
+
+      copy_table_indexes(from, to, options[:rename] || {})
+      copy_table_contents(from, to,
+        @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
+        if to == "altered_#{from}"
+          name = "temp_#{name}"
+        elsif from == "altered_#{to}"
+          name = name[5..-1]
+        end
+
+        to_column_names = columns(to).map(&:name)
+        columns = index.columns.map {|c| rename[c] || c }.select do |column|
+          to_column_names.include?(column)
+        end
+
+        unless columns.empty?
+          # index name can't be the same
+          opts = { :name => name.gsub(/(_?)(#{from})_/, "\\1#{to}_") }
+          opts[:unique] = true if index.unique
+          add_index(to, columns, opts)
+        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}
+      from_columns = columns(from).collect {|col| col.name}
+      columns = columns.find_all{|col| from_columns.include?(column_mappings[col])}
+      quoted_columns = columns.map { |col| quote_column_name(col) } * ','
+
+      quoted_to = quote_table_name(to)
+      execute("SELECT * FROM #{quote_table_name(from)}").each do |row|
+        sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
+        sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
+        sql << ')'
+        execute sql
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/quoted_primary_key.rb

@@ -0,0 +1,28 @@
+module ArJdbc
+  module QuotedPrimaryKeyExtension
+    def self.extended(base)
+      #       Rails 3 method           Rails 2 method
+      meth = [:arel_attributes_values, :attributes_with_quotes].detect do |m|
+        base.private_instance_methods.include?(m.to_s)
+      end
+      pk_hash_key = "self.class.primary_key"
+      pk_hash_value = '"?"'
+      if meth == :arel_attributes_values
+        pk_hash_key = "self.class.arel_table[#{pk_hash_key}]"
+        pk_hash_value = "Arel::SqlLiteral.new(#{pk_hash_value})"
+      end
+      if meth
+        base.module_eval <<-PK, __FILE__, __LINE__
+          alias :#{meth}_pre_pk :#{meth}
+          def #{meth}(include_primary_key = true, *args) #:nodoc:
+            aq = #{meth}_pre_pk(include_primary_key, *args)
+            if connection.is_a?(ArJdbc::Oracle) || connection.is_a?(ArJdbc::Mimer)
+              aq[#{pk_hash_key}] = #{pk_hash_value} if include_primary_key && aq[#{pk_hash_key}].nil?
+            end
+            aq
+          end
+        PK
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/railtie.rb

@@ -0,0 +1,9 @@
+require 'rails/railtie'
+
+module ::ArJdbc
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.expand_path('../rake_tasks.rb', __FILE__)
+    end
+  end
+end

data/lib/arjdbc/jdbc/rake_tasks.rb

@@ -0,0 +1,10 @@
+if defined?(Rake.application) && Rake.application && ENV["SKIP_AR_JDBC_RAKE_REDEFINES"].nil?
+  jdbc_rakefile = File.dirname(__FILE__) + "/jdbc.rake"
+  if Rake.application.lookup("db:create")
+    # rails tasks already defined; load the override tasks now
+    load jdbc_rakefile
+  else
+    # rails tasks not loaded yet; load as an import
+    Rake.application.add_import(jdbc_rakefile)
+  end
+end

data/lib/arjdbc/jdbc/require_driver.rb

@@ -0,0 +1,16 @@
+module Kernel
+  # load a JDBC driver library/gem, failing silently. If failed, trust
+  # that the driver jar is already present through some other means
+  def jdbc_require_driver(path, gem_name = nil)
+    gem_name ||= path.sub('/', '-')
+    2.times do
+      begin
+        require path
+        break
+      rescue LoadError
+        require 'rubygems'
+        begin; gem gem_name; rescue LoadError; end
+      end
+    end
+  end
+end