activerecord-jdbc-adapter 1.0.0.beta1-java → 1.0.0.beta2-java

data/History.txt

@@ -1,5 +1,11 @@
 == 1.0.0
 
+- Thanks to David Kellum, Dmitry Denisov, Dwayne Litzenberger, Gregor
+  Schmidt, James Walker, John Duff, Joshua Suggs, Nicholas J Kreucher,
+  Peter Donald, Geoff Longman, and Ryan Bell for their contributions
+  to this release.
+- BIG set of DB2 updates (Thanks Nick Kreucher)
+- Deprecate jdbc_adapter/rake_tasks
 - (1.0.0.beta1)
 - Make database-specific extensions only load when necessary
 - Allow for discovery of database extensions outside of ar-jdbc
@@ -8,6 +14,37 @@
 - Get AR's own tests running as close to 100% as possible. MySQL is
   currently 100%, SQLite3 is close.
 - JRUBY-4876: Bump up Derby's max index name length (Uwe Kubosch)
+- (1.0.0.beta2)
+- 98 commits since beta1
+- MSSQL updates from dlitz and realityforge
+- ACTIVERECORD_JDBC-131: Fix string slug issue for DB2 (Youhei Kondou)
+- JRUBY-1642: Don't use H2 INFORMATION_SCHEMA in table or column
+  searches
+- JRUBY-4972: Attempt to deal with type(0)/:limit => 0 by not setting
+  it808e213 JRUBY-5040: Fix issue with limits on timestamps in MySQL
+- JRUBY-3555: Allow setting Derby schema with 'schema:' option917ebd9
+  ACTIVERECORD_JDBC-98: Make sure we actuall raise an error when
+  inappropriately configured
+- ACTIVERECORD_JDBC-112: Add schema dumper tests for already-fixed
+  MySQL type limits
+- ACTIVERECORD_JDBC-113: Fix PG float precision issue2c6b1aa No longer
+  need M[ys]SQL escape hatch on case-sensitive test
+- ACTIVERECORD_JDBC-103: Fix decimal options for PG add/change column
+  (Michael Pitman)
+- ACTIVERECORD_JDBC-127: Fix quoting of Date vs. Time(stamp) for
+  Oracle (Lenny Marks)
+- Oracle: Sort out theNUMBER vs NUMBER(x) vs NUMBER(x,y) situation.
+- JRUBY-3051: Think we finally got the PG mixed-case patches applied.
+- JRUBY-5081: Consolidate code for dropping DB via postgres
+- ACTIVERECORD_JDBC-101: Add override of LONGVARCHAR => CLOB for
+  informix
+- ACTIVERECORD_JDBC-107: Fix MySQL update_all issue on AR 2.3
+- ACTIVERECORD_JDBC-124: Filter out special _row_num column
+- ACTIVERECORD_JDBC-126: Fix sql 2000 limit/offset per Michael Pitman
+- ACTIVERECORD_JDBC-125: Add tweak to limit/offset code for HABTM
+  queries (alex b)
+- ACTIVERECORD_JDBC-129: Don't have limits for text, binary or bit
+  fields
 
 == 0.9.7
 

data/Manifest.txt

@@ -15,6 +15,7 @@ lib/active_record/connection_adapters/informix_adapter.rb
 lib/active_record/connection_adapters/jdbc_adapter.rb
 lib/active_record/connection_adapters/jndi_adapter.rb
 lib/active_record/connection_adapters/mssql_adapter.rb
+lib/active_record/connection_adapters/mysql2_adapter.rb
 lib/active_record/connection_adapters/mysql_adapter.rb
 lib/active_record/connection_adapters/oracle_adapter.rb
 lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -24,6 +25,7 @@ lib/arel/engines/sql/compilers/derby_compiler.rb
 lib/arel/engines/sql/compilers/h2_compiler.rb
 lib/arel/engines/sql/compilers/hsqldb_compiler.rb
 lib/arel/engines/sql/compilers/jdbc_compiler.rb
+lib/arel/engines/sql/compilers/mssql_compiler.rb
 lib/arjdbc/cachedb.rb
 lib/arjdbc/db2.rb
 lib/arjdbc/derby.rb
@@ -84,6 +86,7 @@ lib/arjdbc/sqlite3/adapter.rb
 lib/arjdbc/sqlite3/connection_methods.rb
 lib/arjdbc/sybase/adapter.rb
 lib/generators/jdbc/jdbc_generator.rb
+lib/jdbc_adapter/rake_tasks.rb
 lib/jdbc_adapter/version.rb
 lib/arjdbc/jdbc/adapter_java.jar
 test/abstract_db_create.rb
@@ -114,13 +117,16 @@ test/mysql_multibyte_test.rb
 test/mysql_nonstandard_primary_key_test.rb
 test/mysql_simple_test.rb
 test/oracle_simple_test.rb
+test/oracle_specific_test.rb
 test/pick_rails_version.rb
 test/postgres_db_create_test.rb
+test/postgres_drop_db_test.rb
 test/postgres_mixed_case_test.rb
 test/postgres_nonseq_pkey_test.rb
 test/postgres_reserved_test.rb
 test/postgres_schema_search_path_test.rb
 test/postgres_simple_test.rb
+test/postgres_table_alias_length_test.rb
 test/simple.rb
 test/sqlite3_simple_test.rb
 test/sybase_jtds_simple_test.rb
@@ -150,12 +156,14 @@ test/models/string_id.rb
 test/models/validates_uniqueness_of_string.rb
 lib/arjdbc/jdbc/jdbc.rake
 src/java/arjdbc/derby/DerbyModule.java
+src/java/arjdbc/informix/InformixRubyJdbcConnection.java
 src/java/arjdbc/jdbc/AdapterJavaService.java
 src/java/arjdbc/jdbc/JdbcConnectionFactory.java
 src/java/arjdbc/jdbc/RubyJdbcConnection.java
 src/java/arjdbc/jdbc/SQLBlock.java
 src/java/arjdbc/mssql/MssqlRubyJdbcConnection.java
 src/java/arjdbc/mysql/MySQLModule.java
+src/java/arjdbc/oracle/OracleRubyJdbcConnection.java
 src/java/arjdbc/postgresql/PostgresqlRubyJdbcConnection.java
 src/java/arjdbc/sqlite3/Sqlite3RubyJdbcConnection.java
 rakelib/compile.rake

data/README.txt

@@ -2,39 +2,11 @@ activerecord-jdbc-adapter is a database adapter for Rails' ActiveRecord
 component that can be used with JRuby[http://www.jruby.org/]. It allows use of
 virtually any JDBC-compliant database with your JRuby on Rails application.
 
-== Project Info
-
-* Mailing Lists: http://kenai.com/projects/activerecord-jdbc/lists
-* Issues: http://kenai.com/jira/browse/ACTIVERECORD_JDBC
-* Source: git://kenai.com/activerecord-jdbc~main 
-  	  git://github.com/nicksieger/activerecord-jdbc-adapter.git
-
 == Databases
 
-What's there, and what is not there:
-
-* MySQL - Complete support
-* PostgreSQL - Complete support
-* Oracle - Complete support
-* Microsoft SQL Server - Complete support
-* DB2 - Complete, except for the migrations:
-  * change_column 
-  * change_column_default
-  * remove_column
-  * rename_column
-  * add_index
-  * remove_index
-  * rename_table
-* FireBird - Complete, except for change_column_default and rename_column
-* Derby - Complete, except for:
-  * change_column
-  * change_column_default
-  * remove_column
-  * rename_column
-* HSQLDB - Complete
-* H2 - Complete
-* SQLite3 - work in progress
-* Informix - Fairly complete support, all tests pass and migrations appear to work.  Comments welcome.
+Activerecord-jdbc-adapter provides full or nearly full support for:
+MySQL, PostgreSQL, SQLite3, Oracle, Microsoft SQL Server, DB2,
+FireBird, Derby, HSQLDB, H2, and Informix.
 
 Other databases will require testing and likely a custom configuration module.
 Please join the activerecord-jdbc
@@ -48,7 +20,7 @@ support for more databases.
 To use activerecord-jdbc-adapter with JRuby on Rails:
 
 1. Choose the adapter you wish to gem install. The following pre-packaged
-   adapters are available:
+adapters are available:
 
   * base jdbc (<tt>activerecord-jdbc-adapter</tt>). Supports all available databases via JDBC, but requires you to download and manually install the database vendor's JDBC driver .jar file.
   * mysql (<tt>activerecord-jdbcmysql-adapter</tt>)
@@ -60,54 +32,33 @@ To use activerecord-jdbc-adapter with JRuby on Rails:
   * mssql (<tt>activerecord-jdbcmssql-adapter</tt>)
 
 2a. For Rails 3, if you're generating a new application, use the
-    following command to generate your application:
+following command to generate your application:
 
-   jruby -S rails myapp -m http://jruby.org/rails3.rb
+   jruby -S rails new sweetapp -m http://jruby.org/rails3.rb
 
-2b. Otherwise, you'll need to run the "jdbc" generator to prepare your
-    Rails application for JDBC.
+2b. Otherwise, you'll need to perform some extra configuration steps
+to prepare your Rails application for JDBC.
 
-   If you're using Rails 3, first you'll need to modify your Gemfile
-   to use the activerecord-jdbc-adapter gem under JRuby. Change your
-   Gemfile to look like the following (using sqlite3 as an example):
+If you're using Rails 3, you'll need to modify your Gemfile to use the
+activerecord-jdbc-adapter gem under JRuby. Change your Gemfile to look
+like the following (using sqlite3 as an example):
 
     if defined?(JRUBY_VERSION)
-      gem 'activerecord-jdbc-adapter', :require => false
-      gem 'jdbc-sqlite3, :require => false
+      gem 'activerecord-jdbc-adapter'
+      gem 'jdbc-sqlite3'
     else
-      gem sqlite3-ruby', :require => 'sqlite3'
+      gem 'sqlite3-ruby', :require => 'sqlite3'
     end
 
-   Next, run the generator. With Rails 3:
-
-    jruby script/rails generate jdbc
-
-   With Rails 2:
+If you're using Rails 2:
 
     jruby script/generate jdbc
-    
-   The initializer and rake task files generated are guarded such that
-   they won't be loaded if you still run your application under C Ruby.
-
-   Legacy: If you're using Rails prior to version 2.0, you'll need to
-   add one-time setup to your config/environment.rb file in your Rails
-   application. Add the following lines just before the
-   <code>Rails::Initializer</code>. (If you're using
-   activerecord-jdbc-adapter under the old gem name used in versions
-   0.5 and earlier (ActiveRecord-JDBC), replace
-   'activerecord-jdbc-adapter' with 'ActiveRecord-JDBC' below.)
-
-    if RUBY_PLATFORM =~ /java/
-      require 'rubygems'
-      gem 'activerecord-jdbc-adapter'
-      require 'jdbc_adapter'
-    end
 
 3. Configure your database.yml in the normal Rails style. 
 
-   Legacy configuration: If you use one of the convenience
-   'activerecord-jdbcXXX-adapter' adapters, you can still put a 'jdbc'
-   prefix in front of the database adapter name as below.
+Legacy configuration: If you use one of the convenience
+'activerecord-jdbcXXX-adapter' adapters, you can still put a 'jdbc'
+prefix in front of the database adapter name as below.
 
     development:
       adapter: jdbcmysql
@@ -116,8 +67,8 @@ To use activerecord-jdbc-adapter with JRuby on Rails:
       hostname: localhost
       database: weblog_development
 
-   For other databases, you'll need to know the database driver class
-   and URL. Example:
+For other databases, you'll need to know the database driver class and
+URL. Example:
 
     development:
       adapter: jdbc
@@ -126,11 +77,11 @@ To use activerecord-jdbc-adapter with JRuby on Rails:
       driver: com.mysql.jdbc.Driver
       url: jdbc:mysql://localhost:3306/weblog_development
 
-   For JNDI data sources, you may simply specify the database type
-   using the adapter key and the JNDI location as follows:
+   For JNDI data sources, you may simply specify the JNDI location as follows
+   (the adapter will be automatically detected):
 
     production:
-      adapter: mysql
+      adapter: jdbc
       jndi: jdbc/mysqldb
 
 === Standalone, with ActiveRecord
@@ -139,27 +90,19 @@ To use activerecord-jdbc-adapter with JRuby on Rails:
 
     jruby -S gem install activerecord-jdbc-adapter
 
-   If you wish to use the adapter for a specific database, you can install it
-   directly and a driver gem will be installed as well:
+If you wish to use the adapter for a specific database, you can
+install it directly and a driver gem will be installed as well:
 
     jruby -S gem install activerecord-jdbcderby-adapter
 
-2. If using ActiveRecord 2.0 (Rails 2.0) or greater, you can skip to the next
-   step. Otherwise, ensure the following code gets executed in your script:
-
-    require 'rubygems'
-    gem 'activerecord-jdbc-adapter'
-    require 'jdbc_adapter'
-    require 'active_record'
-
-3. After this you can establish a JDBC connection like this:
+2. After this you can establish a JDBC connection like this:
 
     ActiveRecord::Base.establish_connection(
       :adapter => 'jdbcderby',
       :database => "db/my-database"
     )
 
-   or like this (but requires that you manually put the driver jar on the classpath):
+or like this (but requires that you manually put the driver jar on the classpath):
 
     ActiveRecord::Base.establish_connection(
       :adapter => 'jdbc',
@@ -179,12 +122,22 @@ Please file bug reports at
 http://kenai.com/jira/browse/ACTIVERECORD_JDBC. If you're not sure if
 something's a bug, feel free to pre-report it on the mailing lists.
 
+== Project Info
+
+* Mailing Lists: http://kenai.com/projects/activerecord-jdbc/lists
+* Issues: http://kenai.com/jira/browse/ACTIVERECORD_JDBC
+* Source:
+ git://github.com/nicksieger/activerecord-jdbc-adapter.git
+ git://kenai.com/activerecord-jdbc~main 
+
 == Running AR-JDBC's Tests
 
-Drivers for 6 open-source databases are included. Provided you have MySQL
-installed, you can simply type <tt>jruby -S rake</tt> to run the tests. A
-database named <tt>weblog_development</tt> is needed beforehand with a
-connection user of "blog" and an empty password.
+Drivers for 6 open-source databases are included. Provided you have
+MySQL installed, you can simply type <tt>jruby -S rake</tt> to run the
+tests. A database named <tt>weblog_development</tt> is needed
+beforehand with a connection user of "blog" and an empty password. You
+alse need to grant "blog" create privileges on
+'test_rake_db_create.*'.
 
 If you also have PostgreSQL available, those tests will be run if the
 `psql' executable can be found. Also ensure you have a database named

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -0,0 +1 @@
+require 'arjdbc/mysql'

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

@@ -1,6 +1,15 @@
 module Arel
   module SqlCompiler
     class HsqldbCompiler < GenericCompiler
+      def select_sql
+        # HSQLDB needs to add LIMIT in right after SELECT
+        query = super
+        offset = relation.skipped
+        limit = relation.taken
+        @engine.connection.add_limit_offset!(query, :limit => limit,
+                                             :offset => offset) if offset || limit
+        query
+      end
     end
   end
 end

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

@@ -0,0 +1,34 @@
+module Arel
+  module SqlCompiler
+    class MsSQLCompiler < GenericCompiler
+      def select_sql
+        query = super
+        
+        offset = relation.skipped
+        limit = relation.taken
+        @engine.connection.add_limit_offset!(query, :limit => limit, :offset => offset) if offset || limit
+    
+        query
+      end
+      
+      def build_clauses
+        joins   = relation.joins(self)
+        wheres  = relation.where_clauses
+        groups  = relation.group_clauses
+        havings = relation.having_clauses
+        orders  = relation.order_clauses
+
+        clauses = [ "",
+          joins,
+          ("WHERE     #{wheres.join(' AND ')}" unless wheres.empty?),
+          ("GROUP BY  #{groups.join(', ')}" unless groups.empty?),
+          ("HAVING    #{havings.join(' AND ')}" unless havings.empty?),
+          ("ORDER BY  #{orders.join(', ')}" unless orders.empty?)
+        ].compact.join ' '
+
+        clauses << " #{locked}" unless locked.blank?
+        clauses unless clauses.blank?
+      end
+    end
+  end
+end

data/lib/arjdbc/db2/adapter.rb

@@ -1,8 +1,8 @@
 module ArJdbc
   module DB2
-    def self.extended(obj)
-      # Ignore these 4 system tables
-      ActiveRecord::SchemaDumper.ignore_tables |= %w{hmon_atm_info hmon_collection policy stmg_dbsize_info}
+    def self.column_selector
+      [ /(db2|as400)/i,
+        lambda { |cfg, column| column.extend(::ArJdbc::DB2::Column) } ]
     end
 
     module Column
@@ -13,48 +13,114 @@ module ArJdbc
         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
+        when :datetime  then ArJdbc::DB2::Column.cast_to_date_or_time(value)
+        when :date      then ArJdbc::DB2::Column.cast_to_date_or_time(value)
+        when :timestamp then ArJdbc::DB2::Column.cast_to_time(value)
+        when :time      then ArJdbc::DB2::Column.cast_to_time(value)
+        # TODO AS400 stores binary strings in EBCDIC (CCSID 65535), need to convert back to ASCII
+        else
+          super
         end
       end
-      def cast_to_date_or_time(value)
+
+      def type_cast_code(var_name)
+        case type
+        when :datetime  then "ArJdbc::DB2::Column.cast_to_date_or_time(#{var_name})"
+        when :date      then "ArJdbc::DB2::Column.cast_to_date_or_time(#{var_name})"
+        when :timestamp then "ArJdbc::DB2::Column.cast_to_time(#{var_name})"
+        when :time      then "ArJdbc::DB2::Column.cast_to_time(#{var_name})"
+        else
+          super
+        end
+      end
+
+      def self.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)
+      def self.cast_to_time(value)
         return value if value.is_a? Time
-        time_array = ParseDate.parsedate value
+        # AS400 returns a 2 digit year, LUW returns a 4 digit year, so comp = true to help out AS400
+        time_array = ParseDate.parsedate(value, true)
         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)
+      def self.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
+
+      private
+      # <b>DEPRECATED:</b> SMALLINT is now used for boolean field types. Please
+      # convert your tables using DECIMAL(5) for boolean values to SMALLINT instead.
+      def use_decimal5_for_boolean
+        warn "[DEPRECATION] using DECIMAL(5) for boolean is deprecated. Convert your columns to SMALLINT instead."
+        :boolean
+      end
+
+      # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.apdv.java.doc/doc/rjvjdata.html
+      def simplified_type(field_type)
+        case field_type
+        # old jdbc_db2.rb used decimal(5,0) as boolean
+        when /^smallint/i           then :boolean
+        when /^decimal\(5\)$/i      then use_decimal5_for_boolean
+        when /^real/i               then :float
+        when /^timestamp/i          then :datetime
+        else
+          super
+        end
+      end
+
+      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
+      def default_value(value)
+        # IBM i (AS400) will return an empty string instead of null for no default
+        return nil if value.blank?
+
+        # string defaults are surrounded by single quotes
+        return $1 if value =~ /^'(.*)'$/
+
+        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']
+    def _execute(sql, name = nil)
+      if ActiveRecord::ConnectionAdapters::JdbcConnection::select?(sql)
+        @connection.execute_query(sql)
+      elsif ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql)
+        (@connection.execute_insert(sql) or last_insert_id(sql)).to_i
+      else
+        @connection.execute_update(sql)
+      end
+    end
+
+    # holy moly batman! all this to tell AS400 "yes i am sure"
+    def execute_and_auto_confirm(sql)
+      @connection.execute_update "call qsys.qcmdexc('QSYS/CHGJOB INQMSGRPY(*SYSRPYL)',0000000031.00000)"
+      begin
+        @connection.execute_update "call qsys.qcmdexc('ADDRPYLE SEQNBR(9876) MSGID(CPA32B2) RPY(''I'')',0000000045.00000)"
+        execute sql
+      ensure
+        @connection.execute_update "call qsys.qcmdexc('QSYS/CHGJOB INQMSGRPY(*DFT)',0000000027.00000)"
+        @connection.execute_update "call qsys.qcmdexc('RMVRPYLE SEQNBR(9876)',0000000021.00000) "
       end
-      id
+    end
+
+    def last_insert_id(sql)
+      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))
+      result.last['last_insert_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[:integer] = {:limit => nil}
+      tp[:boolean] = {:name => "smallint"}
       tp
     end
 
@@ -63,17 +129,24 @@ module ArJdbc
     end
 
     def add_limit_offset!(sql, options)
-      if limit = options[:limit]
-        offset = options[:offset] || 0
+      limit, offset = options[:limit], options[:offset]
+      if limit && !offset
+        if limit == 1
+          sql << " FETCH FIRST ROW ONLY"
+        else
+          sql << " FETCH FIRST #{sanitize_limit(limit)} ROWS ONLY"
+        end
+      elsif limit && offset
         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}"
+        sql << ") A ) B WHERE B.internal$rownum > #{offset} AND B.internal$rown
+um <= #{sanitize_limit(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]
+      if keys && keys[0]
         # In ActiveRecord side, only downcase names of table and column are handled.
         keys[0] = keys[0].downcase
       end
@@ -85,8 +158,8 @@ module ArJdbc
     end
 
     def quote(value, column = nil) # :nodoc:
-      if column && column.type == :primary_key
-        return value.to_s
+      if column && column.respond_to?(:primary) && column.primary && column.klass != String
+        return value.to_i.to_s
       end
       if column && (column.type == :decimal || column.type == :integer) && value
         return value.to_s
@@ -114,26 +187,113 @@ module ArJdbc
       '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
+    def reorg_table(table_name)
+      unless as400?
+        @connection.execute_update "call sysproc.admin_cmd ('REORG TABLE #{table_name}')"
       end
     end
 
+    def recreate_database(name)
+      tables.each {|table| drop_table("#{db2_schema}.#{table}")}
+    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.
+    # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.admin.dbobj.doc/doc/t0020130.html
+    # ...not supported on IBM i, so we raise in this case
+    def rename_column(table_name, column_name, new_column_name) #:nodoc:
+      if as400?
+        raise NotImplementedError, "rename_column is not supported on IBM i"
+      else
+        execute "ALTER TABLE #{table_name} RENAME COLUMN #{column_name} TO #{new_column_name}"
+        reorg_table(table_name)
+      end
+    end
+
+    def change_column_null(table_name, column_name, null)
+      if null
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} DROP NOT NULL"
+      else
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET NOT NULL"
+      end
+      reorg_table(table_name)
+    end
+
+    def change_column_default(table_name, column_name, default)
+      if default.nil?
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} DROP DEFAULT"
+      else
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET WITH DEFAULT #{quote(default)}"
+      end
+      reorg_table(table_name)
+    end
+
+    def change_column(table_name, column_name, type, options = {})
+      data_type = type_to_sql(type, options[:limit], options[:precision], options[:scale])
+      sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DATA TYPE #{data_type}"
+      as400? ? execute_and_auto_confirm(sql) : execute(sql)
+      reorg_table(table_name)
+
+      if options.include?(:default) and options.include?(:null)
+        # which to run first?
+        if options[:null] or options[:default].nil?
+          change_column_null(table_name, column_name, options[:null])
+          change_column_default(table_name, column_name, options[:default])
+        else
+          change_column_default(table_name, column_name, options[:default])
+          change_column_null(table_name, column_name, options[:null])
+        end
+      elsif options.include?(:default)
+        change_column_default(table_name, column_name, options[:default])
+      elsif options.include?(:null)
+        change_column_null(table_name, column_name, options[:null])
+      end
+    end
+
+    # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.admin.dbobj.doc/doc/t0020132.html
+    def remove_column(table_name, column_name) #:nodoc:
+      sql = "ALTER TABLE #{table_name} DROP COLUMN #{column_name}"
+
+      as400? ? execute_and_auto_confirm(sql) : execute(sql)
+      reorg_table(table_name)
+    end
+
+    # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.sql.ref.doc/doc/r0000980.html
+    def rename_table(name, new_name) #:nodoc:
+      execute "RENAME TABLE #{name} TO #{new_name}"
+      reorg_table(table_name)
+    end
+
+    def tables
+      @connection.tables(nil, db2_schema, nil, ["TABLE"])
+    end
+
+    # only record precision and scale for types that can set
+    # them via CREATE TABLE:
+    # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.sql.ref.doc/doc/r0000927.html
+    HAVE_LIMIT = %w(FLOAT DECFLOAT CHAR VARCHAR CLOB BLOB NCHAR NCLOB DBCLOB GRAPHIC VARGRAPHIC) #TIMESTAMP
+    HAVE_PRECISION = %w(DECIMAL NUMERIC)
+    HAVE_SCALE = %w(DECIMAL NUMERIC)
+
     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)
+      cols = @connection.columns(table_name, name, db2_schema)
+
+      # scrub out sizing info when CREATE TABLE doesn't support it
+      # but JDBC reports it (doh!)
+      for col in cols
+        base_sql_type = col.sql_type.sub(/\(.*/, "").upcase
+        col.limit = nil unless HAVE_LIMIT.include?(base_sql_type)
+        col.precision = nil unless HAVE_PRECISION.include?(base_sql_type)
+        #col.scale = nil unless HAVE_SCALE.include?(base_sql_type)
       end
+
+      cols
+    end
+
+    def indexes(table_name, name = nil)
+      @connection.indexes(table_name, name, db2_schema)
     end
 
     def add_quotes(name)
@@ -152,27 +312,39 @@ module ArJdbc
       name.gsub(/"/,'""')
     end
 
-
     def structure_dump #:nodoc:
       definition=""
-      rs = @connection.connection.meta_data.getTables(nil,nil,nil,["TABLE"].to_java(:string))
+      rs = @connection.connection.meta_data.getTables(nil,db2_schema.upcase,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)
+        rs2 = @connection.connection.meta_data.getColumns(nil,db2_schema.upcase,tname,nil)
         first_col = true
         while rs2.next
           col_name = add_quotes(rs2.getString(4));
           default = ""
           d1 = rs2.getString(13)
-          default = d1 ? " DEFAULT #{d1}" : ""
+          # IBM i (as400 toolbox driver) will return an empty string if there is no default
+          if @config[:url] =~ /^jdbc:as400:/
+            default = !d1.blank? ? " DEFAULT #{d1}" : ""
+          else
+            default = d1 ? " DEFAULT #{d1}" : ""
+          end
 
           type = rs2.getString(6)
-          col_size = rs2.getString(7)
+          col_precision = rs2.getString(7)
+          col_scale = rs2.getString(9)
+          col_size = ""
+          if HAVE_SCALE.include?(type) and col_scale
+            col_size = "(#{col_precision},#{col_scale})"
+          elsif (HAVE_LIMIT + HAVE_PRECISION).include?(type) and col_precision
+            col_size = "(#{col_precision})"
+          end
           nulling = (rs2.getString(18) == 'NO' ? " NOT NULL" : "")
           create_col_string = add_quotes(expand_double_quotes(strip_quotes(col_name))) +
             " " +
             type +
+            col_size +
             "" +
             nulling +
             default
@@ -191,16 +363,24 @@ module ArJdbc
       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})"
+    private
+    def as400?
+        @config[:url] =~ /^jdbc:as400:/
+    end
+
+    def db2_schema
+      if @config[:schema].blank?
+        if as400?
+          # AS400 implementation takes schema from library name (last part of url)
+          schema = @config[:url].split('/').last.strip
+          (schema[-1..-1] == ";") ? schema.chop : schema
+        else
+          # LUW implementation uses schema name of username by default
+          @config[:username] or ENV['USER']
         end
-      rescue ActiveRecord::StatementInvalid
-        # No Schema Info
+      else
+        @config[:schema]
       end
     end
-
   end
 end