ActiveRecord-JDBC 0.3.1 → 0.4

data/History.txt

@@ -1,3 +1,11 @@
+== 0.4
+
+- Release coincides with JRuby 1.0 release
+- Shoring up PostgreSQL (courtesy Dudley Flanders) and HSQL (courtesy Matthew Williams)
+- Fix timestamps on Oracle to use DATE (as everything else)
+- Derby fixes: Fix for open result set issue, better structure dump, quoting, column type changing
+- Sybase type recognition fix (courtesy Dean Mao)
+
 == 0.3.1
 
 * Derby critical fixes shortly after 0.3

data/Manifest.txt

@@ -26,6 +26,7 @@ test/db/jndi_config.rb
 test/db/logger.rb
 test/db/mysql.rb
 test/db/postgres.rb
+test/derby_multibyte_test.rb
 test/derby_simple_test.rb
 test/h2_simple_test.rb
 test/hsqldb_simple_test.rb
@@ -45,3 +46,4 @@ test/models/entry.rb
 test/mysql_simple_test.rb
 test/postgres_simple_test.rb
 test/simple.rb
+lib/tasks/jdbc_databases.rake

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rake'
 require 'rake/testtask'
 
-task :default => :test
+task :default => [:java_compile, :test]
 
 def java_classpath_arg # myriad of ways to discover JRuby classpath
   begin
@@ -40,13 +40,13 @@ end
 desc "Run AR-JDBC tests"
 if RUBY_PLATFORM =~ /java/
   # TODO: add more databases into the standard tests here.
-  task :test => [:java_compile, :test_mysql, :test_derby]
+  task :test => [:test_mysql, :test_derby, :test_hsqldb]
 else
   task :test => [:test_mysql]
 end
 
 Rake::TestTask.new(:test_mysql) do |t|
-  t.test_files = FileList['test/mysql_simple_test.rb']
+  t.test_files = FileList['test/mysql_*_test.rb']
   t.libs << 'test'
 end
 
@@ -56,13 +56,13 @@ Rake::TestTask.new(:test_hsqldb) do |t|
 end
 
 Rake::TestTask.new(:test_derby) do |t|
-  t.test_files = FileList['test/derby_simple_test.rb', 
+  t.test_files = FileList['test/derby_*_test.rb', 
     'test/activerecord/connection_adapters/type_conversion_test.rb']
   t.libs << 'test'
 end
 
 Rake::TestTask.new(:test_postgresql) do |t|
-  t.test_files = FileList['test/postgres_simple_test.rb']
+  t.test_files = FileList['test/postgres_*_test.rb']
   t.libs << 'test'
 end
 
@@ -75,7 +75,7 @@ end
 
 begin
   MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", 
-    "Rakefile", "LICENSE", "lib/**/*.rb", "lib/jdbc_adapter_internal.jar", "test/**/*.rb"]
+    "Rakefile", "LICENSE", "lib/**/*.rb", "lib/jdbc_adapter_internal.jar", "test/**/*.rb", "lib/**/*.rake"]
 
   file "Manifest.txt" => :manifest
   task :manifest do
@@ -84,16 +84,15 @@ begin
   Rake::Task['manifest'].invoke # Always regen manifest, so Hoe has up-to-date list of files
 
   require 'hoe'
-  Hoe.new("ActiveRecord-JDBC", "0.3.1") do |p|
+  Hoe.new("ActiveRecord-JDBC", "0.4") do |p|
     p.rubyforge_name = "jruby-extras"
     p.url = "http://jruby-extras.rubyforge.org/ActiveRecord-JDBC"
     p.author = "Nick Sieger, Ola Bini and JRuby contributors"
-    p.email = "nick@nicksieger.com, ola.bini@ki.se"
+    p.email = "nick@nicksieger.com, ola.bini@gmail.com"
     p.summary = "JDBC adapter for ActiveRecord, for use within JRuby on Rails."
     p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
     p.description = p.paragraphs_of('README.txt', 0...1).join("\n\n")
-    p.extra_deps.reject!{|d| d.first == "hoe"}
-  end
+  end.spec.dependencies.delete_if { |dep| dep.name == "hoe" }
 rescue LoadError
   puts "You really need Hoe installed to be able to package this gem"
 end

data/lib/active_record/connection_adapters/jdbc_adapter.rb

@@ -94,14 +94,16 @@ module ActiveRecord
                           lambda {|r| r['type_name'] =~ /^real$/i},
                           lambda {|r| r['precision'] == '15'}],
         :datetime    => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
-                          lambda {|r| r['type_name'] =~ /^datetime/i},
-                          lambda {|r| r['type_name'] =~ /^timestamp$/i}],
+                          lambda {|r| r['type_name'] =~ /^datetime$/i},
+                          lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^date/i}],
         :timestamp   => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^timestamp$/i},
-                          lambda {|r| r['type_name'] =~ /^datetime/i} ],
+                          lambda {|r| r['type_name'] =~ /^datetime/i},
+                          lambda {|r| r['type_name'] =~ /^date/i}],
         :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^time$/i},
-                          lambda {|r| r['type_name'] =~ /^datetime$/i}],
+                          lambda {|r| r['type_name'] =~ /^date/i}],
         :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^date$/i}],
         :binary      => [ lambda {|r| [Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB].include?(r['data_type'].to_i)},
@@ -118,6 +120,7 @@ module ActiveRecord
 
       def initialize(types)
         @types = types
+        @types.each {|t| t['type_name'] ||= t['local_type_name']} # Sybase driver seems to want 'local_type_name'
       end
 
       def choose_best_types
@@ -139,7 +142,7 @@ module ActiveRecord
           return new_types.first if new_types.length == 1
           types = new_types if new_types.length > 0
         end
-        raise "unable to choose type from: #{types.collect{|t| [t['type_name'],t]}.inspect} for #{ar_type}"        
+        raise "unable to choose type for #{ar_type} from:\n#{types.collect{|t| t['type_name']}.inspect}"
       end
     end
 
@@ -193,7 +196,7 @@ module ActiveRecord
     end
 
     class JdbcConnection
-      attr_reader :adapter
+      attr_reader :adapter, :connection
       
       def initialize(config)
         @config = config.symbolize_keys!
@@ -410,10 +413,10 @@ module ActiveRecord
       def _execute(sql, name = nil)
         log_no_bench(sql, name) do
           case sql.strip
-          when /^(select|show)/i:
-              @connection.execute_query(sql)
           when /^insert/i:
-              @connection.execute_insert(sql)
+            @connection.execute_insert(sql)
+          when /^\(?\s*(select|show)/i:
+            @connection.execute_query(sql)
           else
             @connection.execute_update(sql)
           end
@@ -437,6 +440,10 @@ module ActiveRecord
         @connection.tables
       end
 
+      def indexes(table_name)
+        @connection.indexes(table_name)
+      end
+
       def begin_db_transaction
         @connection.begin
       end

data/lib/jdbc_adapter/jdbc_derby.rb

@@ -2,21 +2,55 @@ require 'jdbc_adapter/missing_functionality_helper'
 
 module JdbcSpec
   module Derby
+    def self.monkey_rails
+      unless @already_monkeyd
+        # Needed because Rails is broken wrt to quoting of 
+        # some values. Most databases are nice about it,
+        # but not Derby. The real issue is that you can't
+        # compare a CHAR value to a NUMBER column.
+        ::ActiveRecord::Associations::ClassMethods.module_eval do
+          private
+
+          def select_limited_ids_list(options, join_dependency)
+            connection.select_all(
+                                  construct_finder_sql_for_association_limiting(options, join_dependency),
+                                  "#{name} Load IDs For Limited Eager Loading"
+                                  ).collect { |row| connection.quote(row[primary_key], columns_hash[primary_key]) }.join(", ")
+          end           
+        end
+
+        @already_monkeyd = true
+      end
+    end
+
+    def self.extended(*args)
+      monkey_rails
+    end
+
+    def self.included(*args)
+      monkey_rails
+    end
+    
     module Column
       def type_cast(value)
         return nil if value.nil? || value =~ /^\s*null\s*$/i
         case type
         when :string    then value
+        when :text    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 :decimal   then self.class.value_to_decimal(value)
         when :float     then value.to_f
         when :datetime  then cast_to_date_or_time(value)
+        when :date      then self.class.string_to_date(value)
         when :timestamp then cast_to_time(value)
         when :binary    then value.scan(/[0-9A-Fa-f]{2}/).collect {|v| v.to_i(16)}.pack("C*")
         when :time      then cast_to_time(value)
+        when :boolean   then self.class.value_to_boolean(value)
         else value
         end
       end
+      
       def cast_to_date_or_time(value)
         return value if value.is_a? Date
         return nil if value.blank?
@@ -37,6 +71,7 @@ module JdbcSpec
 
       def simplified_type(field_type)
         return :boolean if field_type =~ /smallint/i 
+        return :float if field_type =~ /real/i
         super
       end
     end
@@ -46,6 +81,7 @@ module JdbcSpec
     def modify_types(tp)
       tp[:primary_key] = "int generated by default as identity NOT NULL PRIMARY KEY"
       tp[:integer][:limit] = nil
+      tp[:string][:limit] = 256
       tp[:boolean] = {:name => "smallint"}
       tp
     end
@@ -72,8 +108,8 @@ module JdbcSpec
 
     # Set the sequence to the max value of the table's column.
     def reset_sequence!(table, column, sequence = nil)
-      mpk = select_value("SELECT MAX(#{column}) FROM #{table}")
-      execute("ALTER TABLE #{table} ALTER COLUMN #{column} RESTART WITH #{mpk.to_i + 1}")      
+      mpk = select_value("SELECT MAX(#{quote_column_name column}) FROM #{table}")
+      execute("ALTER TABLE #{table} ALTER COLUMN #{quote_column_name column} RESTART WITH #{mpk.to_i + 1}")      
     end
       
     def reset_pk_sequence!(table, pk = nil, sequence = nil)
@@ -88,7 +124,9 @@ module JdbcSpec
     def _execute(sql, name = nil)
       log_no_bench(sql, name) do
         case sql.strip
-        when /^(select|show)/i:
+        when /^insert/i:
+          @connection.execute_insert(sql)
+        when /^\(?\s*(select|show)/i:
           @offset ||= 0
           if !@limit || @limit == -1
             range = @offset..-1
@@ -98,8 +136,6 @@ module JdbcSpec
             max = @offset+@limit+1
           end
           @connection.execute_query(sql,max)[range] || []
-        when /^insert/i:
-          @connection.execute_insert(sql)
         else
           @connection.execute_update(sql)
         end
@@ -125,7 +161,7 @@ module JdbcSpec
     COLUMN_TYPE_STMT = "SELECT COLUMNDATATYPE, COLUMNDEFAULT FROM SYS.SYSCOLUMNS WHERE REFERENCEID = '%s' AND COLUMNNAME = '%s'"
 
     AUTO_INC_STMT = "SELECT AUTOINCREMENTSTART, AUTOINCREMENTINC, COLUMNNAME, REFERENCEID, COLUMNDEFAULT FROM SYS.SYSCOLUMNS WHERE REFERENCEID = '%s' AND COLUMNNAME = '%s'"
-
+    AUTO_INC_STMT2 = "SELECT AUTOINCREMENTSTART, AUTOINCREMENTINC, COLUMNNAME, REFERENCEID, COLUMNDEFAULT FROM SYS.SYSCOLUMNS WHERE REFERENCEID = (SELECT T.TABLEID FROM SYS.SYSTABLES T WHERE T.TABLENAME = '%s') AND COLUMNNAME = '%s'"
 
     def add_quotes(name)
       return name unless name
@@ -160,6 +196,43 @@ module JdbcSpec
       end
       false
     end
+
+    def reinstate_auto_increment(name, refid, coldef)
+      stmt = AUTO_INC_STMT % [refid, strip_quotes(name)]
+      data = execute(stmt).first
+      if data
+        start = data['autoincrementstart']
+        if start
+          coldef << " GENERATED " << (data['columndefault'].nil? ? "ALWAYS" : "BY DEFAULT ")
+          coldef << "AS IDENTITY (START WITH "
+          coldef << start
+          coldef << ", INCREMENT BY "
+          coldef << data['autoincrementinc']
+          coldef << ")"
+          return true
+        end
+      end
+      false
+    end
+
+    def auto_increment_stmt(tname, cname)
+      stmt = AUTO_INC_STMT2 % [tname, strip_quotes(cname)]
+      data = execute(stmt).first
+      if data
+        start = data['autoincrementstart']
+        if start
+          coldef = ""
+          coldef << " GENERATED " << (data['columndefault'].nil? ? "ALWAYS" : "BY DEFAULT ")
+          coldef << "AS IDENTITY (START WITH "
+          coldef << start
+          coldef << ", INCREMENT BY "
+          coldef << data['autoincrementinc']
+          coldef << ")"
+          return coldef
+        end
+      end
+      ""
+    end
     
     def create_column(name, refid, colno)
       stmt = COLUMN_TYPE_STMT % [refid, strip_quotes(name)]
@@ -176,36 +249,57 @@ module JdbcSpec
       coldef
     end
     
+    SIZEABLE = %w(VARCHAR CLOB BLOB)
+    
     def structure_dump #:nodoc:
-      data = ""
-      execute("select tablename, tableid from sys.systables where schemaid not in (select schemaid from sys.sysschemas where schemaname LIKE 'SYS%')").each do |tbl|
-        tid = tbl["tableid"]
-        tname = tbl["tablename"]
-        data << "CREATE TABLE #{tname} (\n"
+      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
-        execute(COLUMN_INFO_STMT % tid).each do |col|
-          col_name = add_quotes(col['columnname']);
-          create_col_string = create_column(col_name, col['referenceid'],col['columnnumber'].to_i)
+        while rs2.next
+          col_name = add_quotes(rs2.getString(4));
+          default = ""
+          d1 = rs2.getString(13)
+          if d1 =~ /^GENERATED_/
+            default = auto_increment_stmt(tname, col_name)
+          elsif d1
+            default = " DEFAULT #{d1}"
+          end
+          
+          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 +
+            (SIZEABLE.include?(type) ? "(#{col_size})" : "") + 
+            nulling +
+            default
           if !first_col
             create_col_string = ",\n #{create_col_string}"
           else
             create_col_string = " #{create_col_string}"
           end
-
-          data << create_col_string
-
+          
+          definition << create_col_string
+          
           first_col = false
         end
-        data << ");\n\n"
+        definition << ");\n\n"
       end
-      data
+      definition
     end
     
     # Support for removing columns added via derby bug issue:
     # https://issues.apache.org/jira/browse/DERBY-1489
     #
-    # This feature has not made it into a formal release and is not in Java 6.  We will
-    # need to conditionally support this somehow (supposed to arrive for 10.3.0.0)
+    # This feature has not made it into a formal release and is not in Java 6.
+    # If the normal strategy fails we fall back on a strategy by creating a new
+    # table without the new column and there after moving the data to the new
+    # 
     def remove_column(table_name, column_name)
       begin
         execute "ALTER TABLE #{table_name} DROP COLUMN #{column_name} RESTRICT"
@@ -213,39 +307,46 @@ module JdbcSpec
         alter_table(table_name) do |definition|
           definition.columns.delete(definition[column_name])
         end
-#        raise NotImplementedError, "remove_column is not support on this Derby version"
       end
     end
     
     # Notes about changing in Derby:
     #    http://db.apache.org/derby/docs/10.2/ref/rrefsqlj81859.html#rrefsqlj81859__rrefsqlj37860)
-    # Derby cannot: Change the column type or decrease the precision of an existing type, but
-    #   can increase the types precision only if it is a VARCHAR.
     #
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
-      # Derby can't change the datatype or size unless the type is varchar
-      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DATA TYPE #{type_to_sql(type, options[:limit])}" if type == :string
-      if options.include? :null
+    # We support changing columns using the strategy outlined in:
+    #    https://issues.apache.org/jira/browse/DERBY-1515
+    #
+    # This feature has not made it into a formal release and is not in Java 6.  We will
+    # need to conditionally support this somehow (supposed to arrive for 10.3.0.0)
+    def change_column(table_name, column_name, type, options = {})
+      # null/not nulling is easy, handle that separately
+      if options.include?(:null)
         # This seems to only work with 10.2 of Derby
-        if options[:null] == false
+        if options.delete(:null) == false
           execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} NOT NULL"
         else
           execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} NULL"
         end
       end
-    end
 
-    # There seems to be more than one thing wrong with 
-    # changing defaults for VARCHAR columns right now... DERBY-2371
-    # among others
-    def change_column_default(table_name, column_name, default) #:nodoc:
-      begin
-        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} DEFAULT #{quote(default)}"
-      rescue
-        alter_table(table_name) do |definition|
-          definition[column_name].default = default
+      # anything left to do?
+      unless options.empty?
+        begin
+          execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DATA TYPE #{type_to_sql(type, options[:limit])}"
+        rescue
+          transaction do
+            temp_new_column_name = "#{column_name}_newtype"
+            # 1) ALTER TABLE t ADD COLUMN c1_newtype NEWTYPE;
+            add_column table_name, temp_new_column_name, type, options
+            # 2) UPDATE t SET c1_newtype = c1;
+            execute "UPDATE #{table_name} SET #{temp_new_column_name} = CAST(#{column_name} AS #{type_to_sql(type, options[:limit])})"
+            # 3) ALTER TABLE t DROP COLUMN c1;
+            remove_column table_name, column_name
+            # 4) ALTER TABLE t RENAME COLUMN c1_newtype to c1;
+            rename_column table_name, temp_new_column_name, column_name
+          end
         end
-      end        
+      end
     end
 
     # Support for renaming columns:
@@ -268,15 +369,8 @@ module JdbcSpec
 
     def recreate_database(db_name)
       tables.each do |t|
-        drop_table t rescue nil
+        drop_table t
       end
-    end    
-    
-    # For migrations, exclude the primary key index as recommended
-    # by the HSQLDB docs.  This is not a great test for primary key
-    # index.
-    def indexes(table_name)
-      @connection.indexes(table_name)
     end
     
     def quote(value, column = nil) # :nodoc:
@@ -288,6 +382,8 @@ module JdbcSpec
           case column.type
           when :binary
             "CAST(x'#{quote_string(value).unpack("C*").collect {|v| v.to_s(16)}.join}' AS BLOB)"
+          when :text
+            "CAST('#{quote_string(value)}' AS CLOB)"
           when :string
             "'#{quote_string(value)}'"
           else
@@ -295,12 +391,23 @@ module JdbcSpec
             if vi.to_s == value
               value
             else
-              "'#{quote_string(value)}'"
+              super
             end
           end
         else
           super
         end
+      when Float, Fixnum, Bignum
+          if column
+            case column.type
+            when :string
+              "'#{quote_string(value.to_s)}'"
+            else
+              super
+            end
+          else
+            super
+          end
       else super
       end
     end
@@ -313,6 +420,10 @@ module JdbcSpec
     def quote_column_name(name) #:nodoc:
       if /^references$/i =~ name
         %Q{"#{name.upcase}"}
+      elsif /[A-Z]/ =~ name && /[a-z]/ =~ name
+        %Q{"#{name}"}
+      elsif name =~ /\s/
+        %Q{"#{name.upcase}"}
       else
         name
       end
@@ -327,3 +438,4 @@ module JdbcSpec
     end
   end
 end
+

data/lib/jdbc_adapter/jdbc_hsqldb.rb

@@ -110,7 +110,9 @@ module JdbcSpec
     end
 
     def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-      execute(sql, name)
+      log_no_bench(sql,name) do
+        @connection.execute_update(sql)
+      end
       table = sql.split(" ", 4)[2]
       id_value || last_insert_id(table, nil)
     end
@@ -136,17 +138,7 @@ module JdbcSpec
     # system tables SYSTEM.*, but H2 seems to name them without
     # any kind of convention
     def tables
-      @connection.tables do |result_row|
-        result_row.get_string(ActiveRecord::ConnectionAdapters::Jdbc::TableMetaData::TABLE_TYPE) !~ /^SYSTEM TABLE$/i
-      end
+      @connection.tables.select {|row| row.to_s !~ /^system_/i }
     end
-
-    # For migrations, exclude the primary key index as recommended
-    # by the HSQLDB docs.  This is not a great test for primary key
-    # index.
-    def indexes(table_name, name = nil)
-      @connection.indexes(table_name.to_s)
-    end
-
   end
 end

data/lib/jdbc_adapter/jdbc_mysql.rb

@@ -58,11 +58,6 @@ module JdbcSpec
     def quote_column_name(name) #:nodoc:
         "`#{name}`"
     end
-
-    # from active_record/vendor/mysql.rb
-    def quote_string(str) #:nodoc:
-      @connection.mysql_quote_string(str)
-    end
     
     def quoted_true
         "1"
@@ -104,10 +99,6 @@ module JdbcSpec
       select_one("SELECT DATABASE() as db")["db"]
     end
     
-    def indexes(table_name, name = nil)#:nodoc:
-      @connection.indexes(table_name)      
-    end
-    
     def create_table(name, options = {}) #:nodoc:
       super(name, {:options => "ENGINE=InnoDB"}.merge(options))
     end

data/lib/jdbc_adapter/jdbc_oracle.rb

@@ -10,6 +10,8 @@ module JdbcSpec
         when :float    then value.to_f
         when :datetime then cast_to_date_or_time(value)
         when :time     then cast_to_time(value)
+        when :decimal   then self.class.value_to_decimal(value)
+        when :boolean   then self.class.value_to_boolean(value)
         else value
         end
       end

data/lib/jdbc_adapter/jdbc_postgre.rb

@@ -57,6 +57,24 @@ module JdbcSpec
       default_seq || "#{table_name}_#{pk || default_pk || 'id'}_seq"
     end
 
+    # Resets sequence to the max value of the table's pk if present.
+    def reset_pk_sequence!(table, pk = nil, sequence = nil)
+      unless pk and sequence
+        default_pk, default_sequence = pk_and_sequence_for(table)
+        pk ||= default_pk
+        sequence ||= default_sequence
+      end
+      if pk
+        if sequence
+          select_value <<-end_sql, 'Reset sequence'
+            SELECT setval('#{sequence}', (SELECT COALESCE(MAX(#{pk})+(SELECT increment_by FROM #{sequence}), (SELECT min_value FROM #{sequence})) FROM #{table}), false)
+          end_sql
+        else
+          @logger.warn "#{table} has primary key #{pk} with no default sequence" if @logger
+        end
+      end
+    end
+
     # Find a table's primary key and sequence.
     def pk_and_sequence_for(table)
       # First try looking for a sequence with a dependency on the
@@ -185,5 +203,9 @@ module JdbcSpec
         'bigint'
       end
     end
+
+    def tables
+      @connection.tables(database_name, nil, nil, ["TABLE"])
+    end
   end  
 end

data/lib/jdbc_adapter/missing_functionality_helper.rb

@@ -3,12 +3,12 @@ module JdbcSpec
     #Taken from SQLite adapter
 
     def alter_table(table_name, options = {}) #:nodoc:
-      table_name = table_name.downcase
+      table_name = table_name.to_s.downcase
       altered_table_name = "altered_#{table_name}"
       caller = lambda {|definition| yield definition if block_given?}
 
       transaction do
-        move_table(table_name, altered_table_name)
+        move_table(table_name, altered_table_name, options)
         move_table(altered_table_name, table_name, &caller)
       end
     end
@@ -25,7 +25,7 @@ module JdbcSpec
           (options[:rename][column.name] ||
            options[:rename][column.name.to_sym] ||
            column.name) : column.name
-
+          column_name = column_name.to_s
           @definition.column(column_name, column.type, 
                              :limit => column.limit, :default => column.default,
                              :null => column.null)
@@ -36,7 +36,7 @@ module JdbcSpec
       
       copy_table_indexes(from, to)
       copy_table_contents(from, to, 
-                          @definition.columns.map {|column| column.name}, 
+                          @definition.columns, 
                           options[:rename] || {})
     end
     
@@ -57,13 +57,13 @@ module JdbcSpec
     end
     
     def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
-      column_mappings = Hash[*columns.map {|name| [name, name]}.flatten]
+      column_mappings = Hash[*columns.map {|col| [col.name, col.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])}
+      columns = columns.find_all{|col| from_columns.include?(column_mappings[col.name])}
       execute("SELECT * FROM #{from}").each do |row|
-        sql = "INSERT INTO #{to} ("+columns*','+") VALUES ("            
-        sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
+        sql = "INSERT INTO #{to} ("+columns.map(&:name)*','+") VALUES ("            
+        sql << columns.map {|col| quote(row[column_mappings[col.name]],col)} * ', '
         sql << ')'
         execute sql
       end

data/lib/tasks/jdbc_databases.rake

@@ -0,0 +1,62 @@
+
+# Task redefine code from public domain
+module Rake
+  module TaskManager
+    def redefine_task(task_class, args, &block)
+      task_name, deps = resolve_args(args)
+      task_name = task_class.scope_name(@scope, task_name)
+      deps = [deps] unless deps.respond_to?(:to_ary)
+      deps = deps.collect {|d| d.to_s }
+      task = @tasks[task_name.to_s] = task_class.new(task_name, self)
+      task.application = self
+      task.add_comment(@last_comment)
+      @last_comment = nil
+      task.enhance(deps, &block)
+      task
+    end
+  end
+  class Task
+    class << self
+      def redefine_task(args, &block)
+        Rake.application.redefine_task(self, args, &block)
+      end
+    end
+  end
+end
+
+def redefine_task(args, &block)
+  Rake::Task.redefine_task(args, &block)
+end
+
+if RUBY_PLATFORM =~ /java/
+  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 }
+        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
+        ActiveRecord::Base.establish_connection(: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|
+          ActiveRecord::Base.connection.execute(ddl)
+        end
+      end
+
+      redefine_task :purge => :environment do
+        abcs = ActiveRecord::Base.configurations
+        ActiveRecord::Base.establish_connection(:test)
+        db = ActiveRecord::Base.connection.database_name
+        ActiveRecord::Base.connection.recreate_database(db)
+      end
+    end  
+  end
+end
+

data/test/derby_multibyte_test.rb

@@ -0,0 +1,12 @@
+# To run this script, run the following in a mysql instance:
+#
+#   drop database if exists weblog_development;
+#   create database weblog_development;
+#   grant all on weblog_development.* to blog@localhost;
+
+require 'jdbc_common'
+require 'db/derby'
+
+class DerbyMultibyteTest < Test::Unit::TestCase
+  include MultibyteTestMethods
+end

data/test/mysql_simple_test.rb

@@ -3,6 +3,7 @@
 #   drop database if exists weblog_development;
 #   create database weblog_development;
 #   grant all on weblog_development.* to blog@localhost;
+#   flush privileges;
 
 require 'jdbc_common'
 require 'db/mysql'

data/test/simple.rb

@@ -114,3 +114,40 @@ module SimpleTestMethods
   end
 
 end
+
+class ActiveRecord::Base
+  cattr_accessor :defined_connections
+end
+
+module MultibyteTestMethods
+  include MigrationSetup
+
+  def setup
+    super
+    config = ActiveRecord::Base.defined_connections["ActiveRecord::Base"].config
+    props = java.util.Properties.new
+    props.setProperty("user", config[:username])
+    props.setProperty("password", config[:password])
+    @java_con = java.sql.DriverManager.getConnection(config[:url], props)
+    @java_con.setAutoCommit(true)
+  end
+
+  def teardown
+    @java_con.close
+    super
+  end
+
+  def test_select_multibyte_string
+    @java_con.createStatement().execute("insert into entries (title) values ('テスト')")
+    entry = Entry.find(:first)
+    assert_equal "テスト", entry.title
+    assert_equal entry, Entry.find_by_title("テスト")
+  end
+
+  def test_update_multibyte_string
+    Entry.create!(:title => "テスト")
+    rs = @java_con.createStatement().executeQuery("select title from entries")
+    assert rs.next
+    assert_equal "テスト", rs.getString(1)
+  end
+end

metadata

@@ -3,12 +3,12 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: ActiveRecord-JDBC
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
-date: 2007-05-07 00:00:00 -05:00
+  version: "0.4"
+date: 2007-06-07 00:00:00 -07:00
 summary: JDBC adapter for ActiveRecord, for use within JRuby on Rails.
 require_paths: 
 - lib
-email: nick@nicksieger.com, ola.bini@ki.se
+email: nick@nicksieger.com, ola.bini@gmail.com
 homepage: http://jruby-extras.rubyforge.org/ActiveRecord-JDBC
 rubyforge_project: jruby-extras
 description: ActiveRecord-JDBC 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.
@@ -57,6 +57,7 @@ files:
 - test/db/logger.rb
 - test/db/mysql.rb
 - test/db/postgres.rb
+- test/derby_multibyte_test.rb
 - test/derby_simple_test.rb
 - test/h2_simple_test.rb
 - test/hsqldb_simple_test.rb
@@ -76,12 +77,16 @@ files:
 - test/mysql_simple_test.rb
 - test/postgres_simple_test.rb
 - test/simple.rb
+- lib/tasks/jdbc_databases.rake
 test_files: []
 
-rdoc_options: []
-
-extra_rdoc_files: []
-
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
 executables: []
 
 extensions: []