kb-activerecord-jdbc-adapter 0.9.7.1-java

data/lib/active_record/connection_adapters/jdbc_adapter_spec.rb

@@ -0,0 +1,26 @@
+module JdbcSpec
+  module ActiveRecordExtensions
+    def self.add_method_to_remove_from_ar_base(meth)
+      @methods ||= []
+      @methods << meth
+    end
+
+    def self.extended(klass)
+      (@methods || []).each {|m| (class << klass; self; end).instance_eval { remove_method(m) rescue nil } }
+    end
+  end
+end
+
+require 'jdbc_adapter/jdbc_mimer'
+require 'jdbc_adapter/jdbc_hsqldb'
+require 'jdbc_adapter/jdbc_oracle'
+require 'jdbc_adapter/jdbc_postgre'
+require 'jdbc_adapter/jdbc_mysql'
+require 'jdbc_adapter/jdbc_derby'
+require 'jdbc_adapter/jdbc_firebird'
+require 'jdbc_adapter/jdbc_db2'
+require 'jdbc_adapter/jdbc_mssql'
+require 'jdbc_adapter/jdbc_cachedb'
+require 'jdbc_adapter/jdbc_sqlite3'
+require 'jdbc_adapter/jdbc_sybase'
+require 'jdbc_adapter/jdbc_informix'

data/lib/active_record/connection_adapters/jndi_adapter.rb

@@ -0,0 +1 @@
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/mssql_adapter.rb

@@ -0,0 +1,13 @@
+tried_gem = false
+begin
+  require "jdbc/jtds"
+rescue LoadError
+  unless tried_gem
+    require 'rubygems'
+    gem "jdbc-mssql"
+    tried_gem = true
+    retry
+  end
+  # trust that the jtds jar is already present
+end
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,13 @@
+tried_gem = false
+begin
+  require "jdbc/mysql"
+rescue LoadError
+  unless tried_gem
+    require 'rubygems'
+    gem "jdbc-mysql"
+    tried_gem = true
+    retry
+  end
+  # trust that the mysql jar is already present
+end
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/oracle_adapter.rb

@@ -0,0 +1 @@
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,13 @@
+tried_gem = false
+begin
+  require "jdbc/postgres"
+rescue LoadError
+  unless tried_gem
+    require 'rubygems'
+    gem "jdbc-postgres"
+    tried_gem = true
+    retry
+  end
+  # trust that the postgres jar is already present
+end
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,13 @@
+tried_gem = false
+begin
+  require "jdbc/sqlite3"
+rescue LoadError
+  unless tried_gem
+    require 'rubygems'
+    gem "jdbc-sqlite3"
+    tried_gem = true
+    retry
+  end
+  # trust that the sqlite jar is already present
+end
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/activerecord-jdbc-adapter.rb

@@ -0,0 +1,6 @@
+require 'jdbc_adapter'
+begin
+  require 'jdbc_adapter/railtie'
+rescue LoadError
+  # Assume we don't have railties in this version of AR
+end

data/lib/arel/engines/sql/compilers/db2_compiler.rb

@@ -0,0 +1,9 @@
+require 'arel/engines/sql/compilers/ibm_db_compiler'
+
+module Arel
+  module SqlCompiler
+    class DB2Compiler < IBM_DBCompiler
+    end
+  end
+end
+

data/lib/arel/engines/sql/compilers/derby_compiler.rb

@@ -0,0 +1,6 @@
+module Arel
+  module SqlCompiler
+    class DerbyCompiler < GenericCompiler
+    end
+  end
+end

data/lib/arel/engines/sql/compilers/h2_compiler.rb

@@ -0,0 +1,6 @@
+module Arel
+  module SqlCompiler
+    class H2Compiler < GenericCompiler
+    end
+  end
+end

data/lib/arel/engines/sql/compilers/hsqldb_compiler.rb

@@ -0,0 +1,6 @@
+module Arel
+  module SqlCompiler
+    class HsqldbCompiler < GenericCompiler
+    end
+  end
+end

data/lib/arel/engines/sql/compilers/jdbc_compiler.rb

@@ -0,0 +1,6 @@
+module Arel
+  module SqlCompiler
+    class JDBCCompiler < GenericCompiler
+    end
+  end
+end

data/lib/generators/jdbc/jdbc_generator.rb

@@ -0,0 +1,9 @@
+class JdbcGenerator < Rails::Generators::Base
+  def self.source_root
+    @source_root ||= File.expand_path('../../../../rails_generators/templates', __FILE__)
+  end
+
+  def create_jdbc_files
+    directory '.', '.'
+  end
+end

data/lib/jdbc_adapter.rb

@@ -0,0 +1,27 @@
+if defined?(JRUBY_VERSION)
+  begin
+    tried_gem ||= false
+    require 'active_record/version'
+  rescue LoadError
+    raise if tried_gem
+    require 'rubygems'
+    gem 'activerecord'
+    tried_gem = true
+    retry
+  end
+  if ActiveRecord::VERSION::MAJOR < 2
+    if defined?(RAILS_CONNECTION_ADAPTERS)
+      RAILS_CONNECTION_ADAPTERS << %q(jdbc)
+    else
+      RAILS_CONNECTION_ADAPTERS = %w(jdbc)
+    end
+    if ActiveRecord::VERSION::MAJOR == 1 && ActiveRecord::VERSION::MINOR == 14
+      require 'active_record/connection_adapters/jdbc_adapter'
+    end
+  else
+    require 'active_record'
+    require 'active_record/connection_adapters/jdbc_adapter'
+  end
+else
+  warn "ActiveRecord-JDBC is for use with JRuby only"
+end

data/lib/jdbc_adapter/jdbc.rake

@@ -0,0 +1,122 @@
+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 => :environment 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
+      ActiveRecord::Base.establish_connection(config)
+      db = ActiveRecord::Base.connection.database_name
+      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 => :environment
+  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 create_database(config)
+    begin
+      ActiveRecord::Base.establish_connection(config)
+      ActiveRecord::Base.connection
+    rescue
+      begin
+        if url = config['url'] && 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
+      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
+      ActiveRecord::Base.connection.recreate_database(db)
+    end
+  end
+end

data/lib/jdbc_adapter/jdbc_cachedb.rb

@@ -0,0 +1,33 @@
+require 'jdbc_adapter/tsql_helper'
+
+module ::JdbcSpec
+  module ActiveRecordExtensions
+    def cachedb_connection( config )
+      config[:port] ||= 1972
+      config[:url] ||= "jdbc:Cache://#{config[:host]}:#{config[:port]}/#{ config[:database]}"
+      config[:driver] ||= "com.intersys.jdbc.CacheDriver"
+      jdbc_connection( config )
+    end
+  end
+
+  module CacheDB
+    include TSqlMethods
+
+    def self.adapter_matcher(name, *)
+     name =~ /cache/i ? self : false
+    end
+
+    def self.column_selector
+      [ /cache/i, lambda {  | cfg, col | col.extend( ::JdbcSpec::CacheDB::Column ) } ]
+    end
+
+    module Column
+    end
+    
+    def create_table(name, options = { })
+      super(name, options)
+      primary_key = options[:primary_key] || "id"
+      execute "ALTER TABLE #{name} ADD CONSTRAINT #{name}_PK PRIMARY KEY(#{primary_key})" unless options[:id] == false
+    end
+  end
+end

data/lib/jdbc_adapter/jdbc_db2.rb

@@ -0,0 +1,222 @@
+module JdbcSpec
+  module DB2
+    def self.adapter_matcher(name, config)
+      if name =~ /db2/i
+         return config[:url] =~ /^jdbc:derby:net:/ ? ::JdbcSpec::Derby : self
+      end
+      false
+    end
+
+    def self.adapter_selector
+      [/db2/i, lambda {|cfg,adapt|
+         if cfg[:url] =~ /^jdbc:derby:net:/
+           adapt.extend(::JdbcSpec::Derby)
+         else
+           adapt.extend(::JdbcSpec::DB2)
+         end }]
+    end
+
+    def self.extended(obj)
+      # Ignore these 4 system tables
+      ActiveRecord::SchemaDumper.ignore_tables |= %w{hmon_atm_info hmon_collection policy stmg_dbsize_info}
+    end
+
+    module Column
+      def type_cast(value)
+        return nil if value.nil? || value =~ /^\s*null\s*$/i
+        case type
+        when :string    then value
+        when :integer   then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
+        when :primary_key then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
+        when :float     then value.to_f
+        when :datetime  then cast_to_date_or_time(value)
+        when :timestamp then cast_to_time(value)
+        when :time      then cast_to_time(value)
+        else value
+        end
+      end
+      def cast_to_date_or_time(value)
+        return value if value.is_a? Date
+        return nil if value.blank?
+        guess_date_or_time((value.is_a? Time) ? value : cast_to_time(value))
+      end
+
+      def cast_to_time(value)
+        return value if value.is_a? Time
+        time_array = ParseDate.parsedate value
+        time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
+        Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
+      end
+
+      def guess_date_or_time(value)
+        (value.hour == 0 and value.min == 0 and value.sec == 0) ?
+        Date.new(value.year, value.month, value.day) : value
+      end
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+      id = super
+      unless id
+        table_name = sql.split(/\s/)[2]
+        result = select(ActiveRecord::Base.send(:sanitize_sql,
+            %[select IDENTITY_VAL_LOCAL() as last_insert_id from #{table_name}],
+            nil))
+        id = result.last['last_insert_id']
+      end
+      id
+    end
+
+    def modify_types(tp)
+      tp[:primary_key] = 'int not null generated by default as identity (start with 1) primary key'
+      tp[:string][:limit] = 255
+      tp[:integer][:limit] = nil
+      tp[:boolean][:limit] = nil
+      tp
+    end
+
+    def adapter_name
+      'DB2'
+    end
+
+    def add_limit_offset!(sql, options)
+      if limit = options[:limit]
+        offset = options[:offset] || 0
+        sql.gsub!(/SELECT/i, 'SELECT B.* FROM (SELECT A.*, row_number() over () AS internal$rownum FROM (SELECT')
+        sql << ") A ) B WHERE B.internal$rownum > #{offset} AND B.internal$rownum <= #{limit + offset}"
+      end
+    end
+
+    def pk_and_sequence_for(table)
+      # In JDBC/DB2 side, only upcase names of table and column are handled.
+      keys = super(table.upcase)
+      if keys[0]
+        # In ActiveRecord side, only downcase names of table and column are handled.
+        keys[0] = keys[0].downcase
+      end
+      keys
+    end
+
+    def quote_column_name(column_name)
+      column_name
+    end
+
+    def quote(value, column = nil) # :nodoc:
+      if column && column.type == :primary_key
+        return value.to_s
+      end
+      if column && (column.type == :decimal || column.type == :integer) && value
+        return value.to_s
+      end
+      case value
+      when String
+        if column && column.type == :binary
+          "BLOB('#{quote_string(value)}')"
+        else
+          "'#{quote_string(value)}'"
+        end
+      else super
+      end
+    end
+
+    def quote_string(string)
+      string.gsub(/'/, "''") # ' (for ruby-mode)
+    end
+
+    def quoted_true
+      '1'
+    end
+
+    def quoted_false
+      '0'
+    end
+
+    def recreate_database(name)
+      do_not_drop = ["stmg_dbsize_info","hmon_atm_info","hmon_collection","policy"]
+      tables.each do |table|
+        unless do_not_drop.include?(table)
+          drop_table(table)
+        end
+      end
+    end
+
+    def remove_index(table_name, options = { })
+      execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
+    end
+
+    # This method makes tests pass without understanding why.
+    # Don't use this in production.
+    def columns(table_name, name = nil)
+      super.select do |col|
+        # strip out "magic" columns from DB2 (?)
+        !/rolename|roleid|create_time|auditpolicyname|auditpolicyid|remarks/.match(col.name)
+      end
+    end
+
+    def add_quotes(name)
+      return name unless name
+      %Q{"#{name}"}
+    end
+
+    def strip_quotes(str)
+      return str unless str
+      return str unless /^(["']).*\1$/ =~ str
+      str[1..-2]
+    end
+
+    def expand_double_quotes(name)
+      return name unless name && name['"']
+      name.gsub(/"/,'""')
+    end
+
+
+    def structure_dump #:nodoc:
+      definition=""
+      rs = @connection.connection.meta_data.getTables(nil,nil,nil,["TABLE"].to_java(:string))
+      while rs.next
+        tname = rs.getString(3)
+        definition << "CREATE TABLE #{tname} (\n"
+        rs2 = @connection.connection.meta_data.getColumns(nil,nil,tname,nil)
+        first_col = true
+        while rs2.next
+          col_name = add_quotes(rs2.getString(4));
+          default = ""
+          d1 = rs2.getString(13)
+          default = d1 ? " DEFAULT #{d1}" : ""
+
+          type = rs2.getString(6)
+          col_size = rs2.getString(7)
+          nulling = (rs2.getString(18) == 'NO' ? " NOT NULL" : "")
+          create_col_string = add_quotes(expand_double_quotes(strip_quotes(col_name))) +
+            " " +
+            type +
+            "" +
+            nulling +
+            default
+          if !first_col
+            create_col_string = ",\n #{create_col_string}"
+          else
+            create_col_string = " #{create_col_string}"
+          end
+
+          definition << create_col_string
+
+          first_col = false
+        end
+        definition << ");\n\n"
+      end
+      definition
+    end
+
+    def dump_schema_information
+      begin
+        if (current_schema = ActiveRecord::Migrator.current_version) > 0
+          #TODO: Find a way to get the DB2 instace name to properly form the statement
+          return "INSERT INTO DB2INST2.SCHEMA_INFO (version) VALUES (#{current_schema})"
+        end
+      rescue ActiveRecord::StatementInvalid
+        # No Schema Info
+      end
+    end
+
+  end
+end