activerecord-jdbc-adapter 0.7.2 → 0.8

data/History.txt

@@ -1,3 +1,17 @@
+== 0.8
+
+- NOTE: This release is only compatible with JRuby 1.1RC3 or later.
+- Because of recent API changes in trunk in preparation for JRuby 1.1, this release is not
+  backward compatible with previous JRuby releases. Hence the version bump.
+- Internal: convert Java methods to be defined with annotations
+- Fix problem with reserved words coming back pre-quoted from #indexes in postgres
+- JRUBY-2205: Fix N^2 allocation of bytelists for mysql quoting (taw)
+- Attempt a fix for Rubyforge 18059
+- Upgrade derby to 10.3.2.1
+- Fix db:create etc. in the case where JDBC is loaded in Rails' preinitializer.rb
+- Fix db:drop to actually work
+- Fix for Rubyforge #11567 (Matt Williams)
+
 == 0.7.2
 
 - JRUBY-1905: add_column for derby, hsqldb, and postgresql (Stephen Bannasch)

data/{LICENSE → LICENSE.txt}

@@ -1,5 +1,5 @@
-Copyright (c) 2006-2007 Nick Sieger <nick@nicksieger.com>
-Copyright (c) 2006-2007 Ola Bini <ola@ologix.com>
+Copyright (c) 2006-2008 Nick Sieger <nick@nicksieger.com>
+Copyright (c) 2006-2008 Ola Bini <ola.bini@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Manifest.txt

@@ -2,7 +2,7 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
-LICENSE
+LICENSE.txt
 lib/active_record/connection_adapters/derby_adapter.rb
 lib/active_record/connection_adapters/h2_adapter.rb
 lib/active_record/connection_adapters/hsqldb_adapter.rb
@@ -60,11 +60,14 @@ test/models/add_not_null_column_to_table.rb
 test/models/auto_id.rb
 test/models/data_types.rb
 test/models/entry.rb
+test/models/reserved_word.rb
 test/mysql_multibyte_test.rb
 test/mysql_simple_test.rb
 test/oracle_simple_test.rb
+test/postgres_reserved_test.rb
 test/postgres_simple_test.rb
 test/simple.rb
+lib/jdbc_adapter/jdbc.rake
 src/java/jdbc_adapter/JdbcAdapterInternalService.java
 src/java/jdbc_adapter/JdbcConnectionFactory.java
 src/java/jdbc_adapter/JdbcDerbySpec.java

data/Rakefile

@@ -20,7 +20,7 @@ task :java_compile do
   pkg_classes = File.join(*%w(pkg classes))
   jar_name = File.join(*%w(lib jdbc_adapter jdbc_adapter_internal.jar))
   mkdir_p pkg_classes
-  sh "javac -target 1.4 -source 1.4 -d pkg/classes #{java_classpath_arg} #{FileList['src/java/**/*.java'].join(' ')}"
+  sh "javac -target 1.5 -source 1.5 -d pkg/classes #{java_classpath_arg} #{FileList['src/java/**/*.java'].join(' ')}"
   sh "jar cf #{jar_name} -C #{pkg_classes} ."
 end
 file "lib/jdbc_adapter/jdbc_adapter_internal.jar" => :java_compile
@@ -87,7 +87,7 @@ end
 
 
 MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", 
-  "Rakefile", "LICENSE", "lib/**/*.rb", "lib/jdbc_adapter/jdbc_adapter_internal.jar", "test/**/*.rb",
+  "Rakefile", "LICENSE.txt", "lib/**/*.rb", "lib/jdbc_adapter/jdbc_adapter_internal.jar", "test/**/*.rb",
    "lib/**/*.rake", "src/**/*.java"]
 
 file "Manifest.txt" => :manifest

data/lib/active_record/connection_adapters/jdbc_adapter.rb

@@ -342,19 +342,19 @@ module ActiveRecord
               next unless index_name
               index_name.downcase!
               column_name = resultset.get_string(Jdbc::IndexMetaData::COLUMN_NAME).downcase
-              
+
               next if primary_keys.include? column_name
-              
+
               # We are working on a new index
               if current_index != index_name
                 current_index = index_name
                 table_name = resultset.get_string(Jdbc::IndexMetaData::TABLE_NAME).downcase
                 non_unique = resultset.get_boolean(Jdbc::IndexMetaData::NON_UNIQUE)
-                
+
                 # empty list for column names, we'll add to that in just a bit
                 indexes << IndexDefinition.new(table_name, index_name, !non_unique, [])
               end
-              
+
               # One or more columns can be associated with an index
               indexes.last.columns << column_name
             end
@@ -404,7 +404,19 @@ module ActiveRecord
 
     end
 
+    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
+        end
+      end
+    end
+
     class JdbcAdapter < AbstractAdapter
+      extend ShadowCoreMethods
+
       attr_reader :config
 
       ADAPTER_TYPES = ::JdbcSpec.constants.map{|c|
@@ -484,14 +496,15 @@ module ActiveRecord
         @connection.reconnect!
         @connection
       end
-      
+
       def disconnect!
         @connection.disconnect!
       end
 
-      def select_all(sql, name = nil)
+      def jdbc_select_all(sql, name = nil)
         select(sql, name)
       end
+      alias_chained_method :select_all, :query_cache, :jdbc_select_all
 
       def select_rows(sql, name = nil)
         rows = []
@@ -508,8 +521,7 @@ module ActiveRecord
           _execute(sql,name)
         end
       end
-      
-      
+
       # we need to do it this way, to allow Rails stupid tests to always work
       # even if we define a new execute method. Instead of mixing in a new
       # execute, an _execute should be mixed in.
@@ -523,18 +535,21 @@ module ActiveRecord
         end
       end
 
-      def update(sql, name = nil) #:nodoc:
+      def jdbc_update(sql, name = nil) #:nodoc:
         execute(sql, name)
       end
+      alias_chained_method :update, :query_dirty, :jdbc_update
 
-      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+      def jdbc_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
         id = execute(sql, name = nil)
         id_value || id
       end
+      alias_chained_method :insert, :query_dirty, :jdbc_insert
 
-      def columns(table_name, name = nil)
+      def jdbc_columns(table_name, name = nil)
         @connection.columns(table_name.to_s)
       end
+      alias_chained_method :columns, :query_cache, :jdbc_columns
 
       def tables
         @connection.tables

data/lib/jdbc_adapter/jdbc.rake

@@ -0,0 +1,78 @@
+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; end
+    existing_task.instance_variable_set "@prerequisites", FileList[]
+    existing_task.instance_variable_set "@actions", []
+  end
+  task(*args, &block)
+end
+
+namespace :db do
+  redefine_task :create => :environment do
+    create_database(ActiveRecord::Base.configurations[RAILS_ENV])
+  end
+
+  class << self; alias_method :previous_create_database, :create_database; end
+  def create_database(config)
+    begin
+      ActiveRecord::Base.establish_connection(config)
+      ActiveRecord::Base.connection
+    rescue
+      begin
+        url = config['url']
+        if url
+          if url =~ /^(.*\/)/
+            url = $1
+          end
+        end
+
+        ActiveRecord::Base.establish_connection(config.merge({'database' => nil, 'url' => url}))
+        ActiveRecord::Base.connection.create_database(config['database'])
+        ActiveRecord::Base.establish_connection(config)
+      rescue
+        previous_create_database(config)
+      end
+    end
+  end
+
+  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)
+    end
+  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
+      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

data/lib/jdbc_adapter/jdbc_hsqldb.rb

@@ -157,6 +157,17 @@ module ::JdbcSpec
       Integer(select_value("SELECT IDENTITY() FROM #{table}"))
     end
 
+    # Override normal #_execute: See Rubyforge #11567
+    def _execute(sql, name = nil)
+      if ::ActiveRecord::ConnectionAdapters::JdbcConnection::select?(sql)
+        @connection.execute_query(sql)
+      elsif ::ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql)
+        insert(sql, name)
+      else
+        @connection.execute_update(sql)
+      end
+    end
+
     def add_limit_offset!(sql, options) #:nodoc:
       offset = options[:offset] || 0
       bef = sql[7..-1]

data/lib/jdbc_adapter/jdbc_mysql.rb

@@ -6,9 +6,6 @@ module ::JdbcSpec
 
   module ActiveRecordExtensions
     def mysql_connection(config)
-      if config[:socket]
-        warn "AR-JDBC MySQL on JRuby does not support sockets"
-      end
       config[:port] ||= 3306
       if config[:url]
         config[:url] = config[:url]['?'] ? "#{config[:url]}&#{MySQL::URL_OPTIONS}" : "#{config[:url]}?#{MySQL::URL_OPTIONS}"
@@ -147,8 +144,12 @@ module ::JdbcSpec
       create_database(name)
     end
     
-    def create_database(name) #:nodoc:
-      execute "CREATE DATABASE `#{name}`"
+    def create_database(name, options = {}) #:nodoc:
+      if options[:collation]
+        execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
+      else
+        execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"
+      end
     end
     
     def drop_database(name) #:nodoc:

data/lib/jdbc_adapter/jdbc_postgre.rb

@@ -177,7 +177,41 @@ module ::JdbcSpec
       end
       @connection.columns_internal(table_name, name, schema_name)
     end
-    
+
+    # From postgresql_adapter.rb
+    def indexes(table_name, name = nil)
+      result = select_rows(<<-SQL, name)
+        SELECT i.relname, d.indisunique, a.attname
+          FROM pg_class t, pg_class i, pg_index d, pg_attribute a
+         WHERE i.relkind = 'i'
+           AND d.indexrelid = i.oid
+           AND d.indisprimary = 'f'
+           AND t.oid = d.indrelid
+           AND t.relname = '#{table_name}'
+           AND a.attrelid = t.oid
+           AND ( d.indkey[0]=a.attnum OR d.indkey[1]=a.attnum
+              OR d.indkey[2]=a.attnum OR d.indkey[3]=a.attnum
+              OR d.indkey[4]=a.attnum OR d.indkey[5]=a.attnum
+              OR d.indkey[6]=a.attnum OR d.indkey[7]=a.attnum
+              OR d.indkey[8]=a.attnum OR d.indkey[9]=a.attnum )
+        ORDER BY i.relname
+      SQL
+
+      current_index = nil
+      indexes = []
+
+      result.each do |row|
+        if current_index != row[0]
+          indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, row[0], row[1] == "t", [])
+          current_index = row[0]
+        end
+
+        indexes.last.columns << row[2]
+      end
+
+      indexes
+    end
+
     def last_insert_id(table, sequence_name)
       Integer(select_value("SELECT currval('#{sequence_name}')"))
     end

data/lib/jdbc_adapter/rake_tasks.rb

@@ -1,82 +1,10 @@
-if defined?(namespace) && RUBY_PLATFORM =~ /java/ && ENV["SKIP_AR_JDBC_RAKE_REDEFINES"].nil?
-  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; end
-      existing_task.instance_variable_set "@prerequisites", FileList[]
-      existing_task.instance_variable_set "@actions", []
-    end
-    task(*args, &block)
-  end
-
-  namespace :db do
-    redefine_task :create => :environment do
-      create_database(ActiveRecord::Base.configurations[RAILS_ENV])
-    end
-
-    def create_database(config)
-      begin
-        ActiveRecord::Base.establish_connection(config)
-        ActiveRecord::Base.connection
-      rescue
-        begin 
-          url = config['url']
-          if url
-            if url =~ /^(.*\/)/
-              url = $1
-            end
-          end
-
-          ActiveRecord::Base.establish_connection(config.merge({'database' => nil, 'url' => url}))
-          ActiveRecord::Base.connection.create_database(config['database'])
-          ActiveRecord::Base.establish_connection(config)
-        rescue
-          if (config['driver'] || config['adapter']) =~ /postgr/
-            `createdb "#{config['database']}" -E utf8`
-          else 
-            warn "couldn't create database #{config['database']}"
-          end
-        end
-      end
-    end
-    
-    redefine_task :drop => :environment do
-      begin
-        config = ActiveRecord::Base.configurations[environment_name]
-        ActiveRecord::Base.establish_connection(config)
-        db = ActiveRecord::Base.connection.database_name
-        ActiveRecord::Base.connection.recreate_database(db)
-      rescue
-      end
-    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
-        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
+if defined?(Rake.application) && Rake.application && ENV["SKIP_AR_JDBC_RAKE_REDEFINES"].nil?
+  jdbc_rakefile = File.dirname(__FILE__) + "/jdbc.rake"
+  if Rake.application.lookup("environment")
+    # 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/jdbc_adapter/version.rb

@@ -1,5 +1,5 @@
 module JdbcAdapter
   module Version
-    VERSION = "0.7.2"
+    VERSION = "0.8"
   end
 end

data/src/java/jdbc_adapter/JdbcAdapterInternalService.java

@@ -59,14 +59,13 @@ import org.jruby.RubyObjectAdapter;
 import org.jruby.RubyString;
 import org.jruby.RubySymbol;
 import org.jruby.RubyTime;
-import org.jruby.
-exceptions.RaiseException;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
 import org.jruby.javasupport.Java;
 import org.jruby.javasupport.JavaEmbedUtils;
 import org.jruby.javasupport.JavaObject;
 import org.jruby.runtime.Arity;
 import org.jruby.runtime.Block;
-import org.jruby.runtime.CallbackFactory;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.load.BasicLibraryService;
@@ -76,43 +75,14 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
     private static RubyObjectAdapter rubyApi;
 
     public boolean basicLoad(final Ruby runtime) throws IOException {
-        RubyClass cJdbcConn = ((RubyModule)(runtime.getModule("ActiveRecord").getConstant("ConnectionAdapters"))).
+        RubyModule jdbcConnection = ((RubyModule)(runtime.getModule("ActiveRecord").getConstant("ConnectionAdapters"))).
             defineClassUnder("JdbcConnection",runtime.getObject(),runtime.getObject().getAllocator());
-
-        CallbackFactory cf = runtime.callbackFactory(JdbcAdapterInternalService.class);
-        cJdbcConn.defineMethod("unmarshal_result",cf.getSingletonMethod("unmarshal_result", IRubyObject.class));
-        cJdbcConn.defineMethod("with_connection_retry_guard",cf.getSingletonMethod("with_connection_retry_guard"));
-        cJdbcConn.defineFastMethod("connection",cf.getFastSingletonMethod("connection"));
-        cJdbcConn.defineFastMethod("reconnect!",cf.getFastSingletonMethod("reconnect"));
-        cJdbcConn.defineFastMethod("disconnect!",cf.getFastSingletonMethod("disconnect"));
-        cJdbcConn.defineFastMethod("execute_update",cf.getFastSingletonMethod("execute_update", IRubyObject.class));
-        cJdbcConn.defineFastMethod("execute_query",cf.getFastOptSingletonMethod("execute_query")); 
-        cJdbcConn.defineFastMethod("execute_insert",cf.getFastSingletonMethod("execute_insert", IRubyObject.class));
-        cJdbcConn.defineFastMethod("execute_id_insert",cf.getFastSingletonMethod("execute_id_insert", IRubyObject.class, IRubyObject.class));
-        cJdbcConn.defineFastMethod("primary_keys",cf.getFastSingletonMethod("primary_keys", IRubyObject.class));
-        cJdbcConn.defineFastMethod("set_native_database_types",cf.getFastSingletonMethod("set_native_database_types"));
-        cJdbcConn.defineFastMethod("native_database_types",cf.getFastSingletonMethod("native_database_types"));
-        cJdbcConn.defineFastMethod("begin",cf.getFastSingletonMethod("begin"));
-        cJdbcConn.defineFastMethod("commit",cf.getFastSingletonMethod("commit"));
-        cJdbcConn.defineFastMethod("rollback",cf.getFastSingletonMethod("rollback"));
-        cJdbcConn.defineFastMethod("database_name",cf.getFastSingletonMethod("database_name"));
-        cJdbcConn.defineFastMethod("columns",cf.getFastOptSingletonMethod("columns_internal"));
-        cJdbcConn.defineFastMethod("columns_internal",cf.getFastOptSingletonMethod("columns_internal"));
-        cJdbcConn.defineFastMethod("tables",cf.getFastOptSingletonMethod("tables"));
-
-        cJdbcConn.defineFastMethod("insert_bind",cf.getFastOptSingletonMethod("insert_bind"));
-        cJdbcConn.defineFastMethod("update_bind",cf.getFastOptSingletonMethod("update_bind"));
-
-        cJdbcConn.defineFastMethod("write_large_object",cf.getFastOptSingletonMethod("write_large_object"));
-
-        cJdbcConn.getMetaClass().defineFastMethod("insert?",cf.getFastSingletonMethod("insert_p", IRubyObject.class));
-        cJdbcConn.getMetaClass().defineFastMethod("select?",cf.getFastSingletonMethod("select_p", IRubyObject.class));
-
+        jdbcConnection.defineAnnotatedMethods(JdbcAdapterInternalService.class);
         RubyModule jdbcSpec = runtime.getOrCreateModule("JdbcSpec");
 
         rubyApi = JavaEmbedUtils.newObjectAdapter();
-        JdbcMySQLSpec.load(runtime, jdbcSpec);
-        JdbcDerbySpec.load(runtime, jdbcSpec, rubyApi);
+        JdbcMySQLSpec.load(jdbcSpec);
+        JdbcDerbySpec.load(jdbcSpec, rubyApi);
         return true;
     }
 
@@ -132,6 +102,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         return p;
     }
 
+    @JRubyMethod(name = "insert?", required = 1, meta = true)
     public static IRubyObject insert_p(IRubyObject recv, IRubyObject _sql) {
         ByteList bl = rubyApi.convertToRubyString(_sql).getByteList();
 
@@ -170,6 +141,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         return recv.getRuntime().getFalse();
     }
 
+    @JRubyMethod(name = "select?", required = 1, meta = true)
     public static IRubyObject select_p(IRubyObject recv, IRubyObject _sql) {
         ByteList bl = rubyApi.convertToRubyString(_sql).getByteList();
 
@@ -225,6 +197,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         return recv.getRuntime().getFalse();
     }
 
+    @JRubyMethod(name = "connection")
     public static IRubyObject connection(IRubyObject recv) {
         Connection c = getConnection(recv);
         if (c == null) {
@@ -233,16 +206,19 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         return rubyApi.getInstanceVariable(recv, "@connection");
     }
 
+    @JRubyMethod(name = "disconnect!")
     public static IRubyObject disconnect(IRubyObject recv) {
         setConnection(recv, null);
         return recv;
     }
 
+    @JRubyMethod(name = "reconnect!")
     public static IRubyObject reconnect(IRubyObject recv) {
         setConnection(recv, getConnectionFactory(recv).newConnection());
         return recv;
     }
 
+    @JRubyMethod(name = "with_connection_retry_guard", frame = true)
     public static IRubyObject with_connection_retry_guard(final IRubyObject recv, final Block block) {
         return withConnectionAndRetry(recv, new SQLBlock() {
             public IRubyObject call(Connection c) throws SQLException {
@@ -323,6 +299,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         };
     }
 
+    @JRubyMethod(name = "tables", rest = true)
     public static IRubyObject tables(final IRubyObject recv, IRubyObject[] args) {
         final Ruby runtime     = recv.getRuntime();
         final String catalog   = getCatalog(args);
@@ -371,10 +348,12 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         return types;
     }
 
+    @JRubyMethod(name = "native_database_types")
     public static IRubyObject native_database_types(IRubyObject recv) {
         return rubyApi.getInstanceVariable(recv, "@tps");
     }    
 
+    @JRubyMethod(name = "set_native_database_types")
     public static IRubyObject set_native_database_types(IRubyObject recv) throws SQLException, IOException {
         Ruby runtime = recv.getRuntime();
         IRubyObject types = unmarshal_result_downcase(recv, getConnection(recv).getMetaData().getTypeInfo());
@@ -384,6 +363,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         return runtime.getNil();
     }
 
+    @JRubyMethod(name = "database_name")
     public static IRubyObject database_name(IRubyObject recv) throws SQLException {
         String name = getConnection(recv).getCatalog();
         if(null == name) {
@@ -395,11 +375,13 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         return recv.getRuntime().newString(name);
     }
 
+    @JRubyMethod(name = "begin")
     public static IRubyObject begin(IRubyObject recv) throws SQLException {
         getConnection(recv).setAutoCommit(false);
         return recv.getRuntime().getNil();
     }
 
+    @JRubyMethod(name = "commit")
     public static IRubyObject commit(IRubyObject recv) throws SQLException {
         try {
             getConnection(recv).commit();
@@ -409,6 +391,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         }
     }
 
+    @JRubyMethod(name = "rollback")
     public static IRubyObject rollback(IRubyObject recv) throws SQLException {
         try {
             getConnection(recv).rollback();
@@ -418,6 +401,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         }
     }
 
+    @JRubyMethod(name = {"columns", "columns_internal"}, required = 1, optional = 2)
     public static IRubyObject columns_internal(final IRubyObject recv, final IRubyObject[] args) throws SQLException, IOException {
         return withConnectionAndRetry(recv, new SQLBlock() {
             public IRubyObject call(Connection c) throws SQLException {
@@ -549,6 +533,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         }
     }
 
+    @JRubyMethod(name = "primary_keys", required = 1)
     public static IRubyObject primary_keys(final IRubyObject recv, final IRubyObject _table_name) throws SQLException {
         return withConnectionAndRetry(recv, new SQLBlock() {
             public IRubyObject call(Connection c) throws SQLException {
@@ -580,6 +565,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         });
     }
 
+    @JRubyMethod(name = "execute_id_insert", required = 2)
     public static IRubyObject execute_id_insert(IRubyObject recv, final IRubyObject sql, final IRubyObject id) throws SQLException {
         return withConnectionAndRetry(recv, new SQLBlock() {
             public IRubyObject call(Connection c) throws SQLException {
@@ -595,6 +581,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         });
     }
 
+    @JRubyMethod(name = "execute_update", required = 1)
     public static IRubyObject execute_update(final IRubyObject recv, final IRubyObject sql) throws SQLException {
         return withConnectionAndRetry(recv, new SQLBlock() {
             public IRubyObject call(Connection c) throws SQLException {
@@ -614,6 +601,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         });
     }
 
+    @JRubyMethod(name = "execute_query", rest = true)
     public static IRubyObject execute_query(final IRubyObject recv, IRubyObject[] args) throws SQLException, IOException {
         final IRubyObject sql = args[0];
         final int maxrows;
@@ -643,6 +631,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         });
     }
 
+    @JRubyMethod(name = "execute_insert", required = 1)
     public static IRubyObject execute_insert(final IRubyObject recv, final IRubyObject sql) throws SQLException {
         return withConnectionAndRetry(recv, new SQLBlock() {
             public IRubyObject call(Connection c) throws SQLException {
@@ -735,6 +724,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         return runtime.newArray(results);
     }
 
+    @JRubyMethod(name = "unmarshal_result", required = 1)
     public static IRubyObject unmarshal_result(IRubyObject recv, IRubyObject resultset, Block row_filter) throws SQLException, IOException {
         Ruby runtime = recv.getRuntime();
         ResultSet rs = intoResultSet(resultset);
@@ -897,7 +887,8 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
     
     private final static DateFormat FORMAT = new SimpleDateFormat("%y-%M-%d %H:%m:%s");
 
-    private static void setValue(PreparedStatement ps, int index, Ruby runtime, IRubyObject value, IRubyObject type) throws SQLException {
+    private static void setValue(PreparedStatement ps, int index, Ruby runtime, ThreadContext context,
+            IRubyObject value, IRubyObject type) throws SQLException {
         final int tp = getTypeValueFor(runtime, type);
         if(value.isNil()) {
             ps.setNull(index, tp);
@@ -907,7 +898,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         switch(tp) {
         case Types.VARCHAR:
         case Types.CLOB:
-            ps.setString(index, RubyString.objAsString(value).toString());
+            ps.setString(index, RubyString.objAsString(context, value).toString());
             break;
         case Types.INTEGER:
             ps.setLong(index, RubyNumeric.fix2long(value));
@@ -920,10 +911,10 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         case Types.DATE:
             if(!(value instanceof RubyTime)) {
                 try {
-                    Date dd = FORMAT.parse(RubyString.objAsString(value).toString());
+                    Date dd = FORMAT.parse(RubyString.objAsString(context, value).toString());
                     ps.setTimestamp(index, new java.sql.Timestamp(dd.getTime()), Calendar.getInstance());
                 } catch(Exception e) {
-                    ps.setString(index, RubyString.objAsString(value).toString());
+                    ps.setString(index, RubyString.objAsString(context, value).toString());
                 }
             } else {
                 RubyTime rubyTime = (RubyTime) value;
@@ -944,27 +935,28 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
         }
     }
 
-    private static void setValuesOnPS(PreparedStatement ps, Ruby runtime, IRubyObject values, IRubyObject types) throws SQLException {
+    private static void setValuesOnPS(PreparedStatement ps, Ruby runtime, ThreadContext context,
+            IRubyObject values, IRubyObject types) throws SQLException {
         RubyArray vals = (RubyArray)values;
         RubyArray tps = (RubyArray)types;
 
         for(int i=0, j=vals.getLength(); i<j; i++) {
-            setValue(ps, i+1, runtime, vals.eltInternal(i), tps.eltInternal(i));
+            setValue(ps, i+1, runtime, context, vals.eltInternal(i), tps.eltInternal(i));
         }
     }
 
     /*
      * sql, values, types, name = nil, pk = nil, id_value = nil, sequence_name = nil
      */
-    public static IRubyObject insert_bind(IRubyObject recv, final IRubyObject[] args) throws SQLException {
+    @JRubyMethod(name = "insert_bind", required = 3, rest = true)
+    public static IRubyObject insert_bind(final ThreadContext context, IRubyObject recv, final IRubyObject[] args) throws SQLException {
         final Ruby runtime = recv.getRuntime();
-        Arity.checkArgumentCount(runtime, args, 3, 7);
         return withConnectionAndRetry(recv, new SQLBlock() {
             public IRubyObject call(Connection c) throws SQLException {
                 PreparedStatement ps = null;
                 try {
                     ps = c.prepareStatement(rubyApi.convertToRubyString(args[0]).toString(), Statement.RETURN_GENERATED_KEYS);
-                    setValuesOnPS(ps, runtime, args[1], args[2]);
+                    setValuesOnPS(ps, runtime, context, args[1], args[2]);
                     ps.executeUpdate();
                     return unmarshal_id_result(runtime, ps.getGeneratedKeys());
                 } finally {
@@ -980,7 +972,8 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
     /*
      * sql, values, types, name = nil
      */
-    public static IRubyObject update_bind(IRubyObject recv, final IRubyObject[] args) throws SQLException {
+    @JRubyMethod(name = "update_bind", required = 3, rest = true)
+    public static IRubyObject update_bind(final ThreadContext context, IRubyObject recv, final IRubyObject[] args) throws SQLException {
         final Ruby runtime = recv.getRuntime();
         Arity.checkArgumentCount(runtime, args, 3, 4);
         return withConnectionAndRetry(recv, new SQLBlock() {
@@ -988,7 +981,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
                 PreparedStatement ps = null;
                 try {
                     ps = c.prepareStatement(rubyApi.convertToRubyString(args[0]).toString());
-                    setValuesOnPS(ps, runtime, args[1], args[2]);
+                    setValuesOnPS(ps, runtime, context, args[1], args[2]);
                     ps.executeUpdate();
                 } finally {
                     try {
@@ -1004,10 +997,10 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
     /*
      * (is binary?, colname, tablename, primary key, id, value)
      */
+    @JRubyMethod(name = "write_large_object", required = 6)
     public static IRubyObject write_large_object(IRubyObject recv, final IRubyObject[] args)
             throws SQLException, IOException {
         final Ruby runtime = recv.getRuntime();
-        Arity.checkArgumentCount(runtime, args, 6, 6);
         return withConnectionAndRetry(recv, new SQLBlock() {
             public IRubyObject call(Connection c) throws SQLException {
                 String sql = "UPDATE " + rubyApi.convertToRubyString(args[2])

data/src/java/jdbc_adapter/JdbcDerbySpec.java

@@ -35,83 +35,76 @@ import org.jruby.RubyBigDecimal;
 import org.jruby.RubyRange;
 import org.jruby.RubyNumeric;
 
-import org.jruby.runtime.Arity;
-import org.jruby.runtime.CallbackFactory;
-import org.jruby.runtime.MethodIndex;
 import org.jruby.runtime.builtin.IRubyObject;
 
 import org.jruby.util.ByteList;
 
 import java.sql.SQLException;
 import org.jruby.RubyObjectAdapter;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
 
 public class JdbcDerbySpec {
     private static RubyObjectAdapter rubyApi;
-    public static void load(Ruby runtime, RubyModule jdbcSpec, RubyObjectAdapter adapter) {
+    public static void load(RubyModule jdbcSpec, RubyObjectAdapter adapter) {
         RubyModule derby = jdbcSpec.defineModuleUnder("Derby");
-        CallbackFactory cf = runtime.callbackFactory(JdbcDerbySpec.class);
-        derby.defineFastMethod("quote_string",cf.getFastSingletonMethod("quote_string",IRubyObject.class));
-        derby.defineFastMethod("quote",cf.getFastOptSingletonMethod("quote"));
-        derby.defineFastMethod("_execute",cf.getFastOptSingletonMethod("_execute"));
-        derby.defineFastMethod("add_limit_offset!",cf.getFastSingletonMethod("add_limit_offset", IRubyObject.class, IRubyObject.class));
-        derby.defineFastMethod("select_all",cf.getFastOptSingletonMethod("select_all"));
-        derby.defineFastMethod("select_one",cf.getFastOptSingletonMethod("select_one"));
-        RubyModule col = derby.defineModuleUnder("Column");
-        col.defineFastMethod("type_cast",cf.getFastSingletonMethod("type_cast", IRubyObject.class));
+        derby.defineAnnotatedMethods(JdbcDerbySpec.class);
+        RubyModule column = derby.defineModuleUnder("Column");
+        column.defineAnnotatedMethods(Column.class);
         rubyApi = adapter;
     }
 
-    /*
-     * JdbcSpec::Derby::Column.type_cast(value)
-     */
-    public static IRubyObject type_cast(IRubyObject recv, IRubyObject value) {
-        Ruby runtime = recv.getRuntime();
+    public static class Column {
+        @JRubyMethod(name = "type_cast", required = 1)
+        public static IRubyObject type_cast(IRubyObject recv, IRubyObject value) {
+            Ruby runtime = recv.getRuntime();
 
-        if (value.isNil() || ((value instanceof RubyString) && value.toString().trim().equalsIgnoreCase("null"))) {
-            return runtime.getNil();
-        }
+            if (value.isNil() || ((value instanceof RubyString) && value.toString().trim().equalsIgnoreCase("null"))) {
+                return runtime.getNil();
+            }
 
-        String type = rubyApi.getInstanceVariable(recv,"@type").toString();
+            String type = rubyApi.getInstanceVariable(recv, "@type").toString();
 
-        switch(type.charAt(0)) {
-        case 's': //string
-            return value;
-        case 't': //text, timestamp, time
-            if(type.equals("text")) {
-                return value;
-            } else {
-                return rubyApi.callMethod(recv, "cast_to_time", value);
-            }
-        case 'i': //integer
-        case 'p': //primary key
-            if (value.respondsTo("to_i")) {
-                return rubyApi.callMethod(value, "to_i");
-            } else {
-                return runtime.newFixnum(value.isTrue() ? 1 : 0 );
-            }
-        case 'd': //decimal, datetime, date
-            if(type.equals("datetime")) {
-                return rubyApi.callMethod(recv, "cast_to_date_or_time", value);
-            } else if(type.equals("date")) {
-                return rubyApi.callMethod(recv.getMetaClass(), "string_to_date", value);
-            } else {
-                return rubyApi.callMethod(recv.getMetaClass(), "value_to_decimal", value);
-            }
-        case 'f': //float
-            return rubyApi.callMethod(value,"to_f");
-        case 'b': //binary, boolean
-            if (type.equals("binary")) {
-                return rubyApi.callMethod(recv, "value_to_binary", value);
-            } else {
-                return rubyApi.callMethod(recv.getMetaClass(), "value_to_boolean", value);
+            switch (type.charAt(0)) {
+                case 's': //string
+                    return value;
+                case 't': //text, timestamp, time
+                    if (type.equals("text")) {
+                        return value;
+                    } else {
+                        return rubyApi.callMethod(recv, "cast_to_time", value);
+                    }
+                case 'i': //integer
+                case 'p': //primary key
+                    if (value.respondsTo("to_i")) {
+                        return rubyApi.callMethod(value, "to_i");
+                    } else {
+                        return runtime.newFixnum(value.isTrue() ? 1 : 0);
+                    }
+                case 'd': //decimal, datetime, date
+                    if (type.equals("datetime")) {
+                        return rubyApi.callMethod(recv, "cast_to_date_or_time", value);
+                    } else if (type.equals("date")) {
+                        return rubyApi.callMethod(recv.getMetaClass(), "string_to_date", value);
+                    } else {
+                        return rubyApi.callMethod(recv.getMetaClass(), "value_to_decimal", value);
+                    }
+                case 'f': //float
+                    return rubyApi.callMethod(value, "to_f");
+                case 'b': //binary, boolean
+                    if (type.equals("binary")) {
+                        return rubyApi.callMethod(recv, "value_to_binary", value);
+                    } else {
+                        return rubyApi.callMethod(recv.getMetaClass(), "value_to_boolean", value);
+                    }
             }
+            return value;
         }
-        return value;
     }
 
-    public static IRubyObject quote(IRubyObject recv, IRubyObject[] args) {
+    @JRubyMethod(name = "quote", required = 1, optional = 1)
+    public static IRubyObject quote(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
         Ruby runtime = recv.getRuntime();
-        Arity.checkArgumentCount(runtime, args, 1, 2);
         IRubyObject value = args[0];
         if (args.length > 1) {
             IRubyObject col = args[1];
@@ -128,21 +121,21 @@ public class JdbcDerbySpec {
                     if (only_digits((RubyString)value)) {
                         return value;
                     } else {
-                        return super_quote(recv, runtime, value, col);
+                        return super_quote(context, recv, runtime, value, col);
                     }
                 }
             } else if ((value instanceof RubyFloat) || (value instanceof RubyFixnum) || (value instanceof RubyBignum)) {
                 if (type == runtime.newSymbol("string")) {
-                    return quote_string_with_surround(runtime, "'", RubyString.objAsString(value), "'");
+                    return quote_string_with_surround(runtime, "'", RubyString.objAsString(context, value), "'");
                 }
             }
         } 
-        return super_quote(recv, runtime, value, runtime.getNil());
+        return super_quote(context, recv, runtime, value, runtime.getNil());
     }
 
     private final static ByteList NULL = new ByteList("NULL".getBytes());
 
-    public static IRubyObject super_quote(IRubyObject recv, Ruby runtime, IRubyObject value, IRubyObject col) {
+    private static IRubyObject super_quote(ThreadContext context, IRubyObject recv, Ruby runtime, IRubyObject value, IRubyObject col) {
         if (value.respondsTo("quoted_id")) {
             return rubyApi.callMethod(value, "quoted_id");
         }
@@ -151,11 +144,11 @@ public class JdbcDerbySpec {
         RubyModule multibyteChars = (RubyModule) 
                 ((RubyModule) ((RubyModule) runtime.getModule("ActiveSupport")).getConstant("Multibyte")).getConstantAt("Chars");
         if (value instanceof RubyString || rubyApi.isKindOf(value, multibyteChars)) {
-            RubyString svalue = RubyString.objAsString(value);
+            RubyString svalue = RubyString.objAsString(context, value);
             if (type == runtime.newSymbol("binary") && col.getType().respondsTo("string_to_binary")) {
                 return quote_string_with_surround(runtime, "'", (RubyString)(rubyApi.callMethod(col.getType(), "string_to_binary", svalue)), "'"); 
             } else if (type == runtime.newSymbol("integer") || type == runtime.newSymbol("float")) {
-                return RubyString.objAsString(((type == runtime.newSymbol("integer")) ? 
+                return RubyString.objAsString(context, ((type == runtime.newSymbol("integer")) ?
                                                rubyApi.callMethod(svalue, "to_i") : 
                                                rubyApi.callMethod(svalue, "to_f")));
             } else {
@@ -168,11 +161,11 @@ public class JdbcDerbySpec {
                     (type == runtime.newSymbol(":integer")) ? runtime.newString("1") : rubyApi.callMethod(recv, "quoted_true") :
                     (type == runtime.newSymbol(":integer")) ? runtime.newString("0") : rubyApi.callMethod(recv, "quoted_false"));
         } else if((value instanceof RubyFloat) || (value instanceof RubyFixnum) || (value instanceof RubyBignum)) {
-            return RubyString.objAsString(value);
+            return RubyString.objAsString(context, value);
         } else if(value instanceof RubyBigDecimal) {
             return rubyApi.callMethod(value, "to_s", runtime.newString("F"));
         } else if (rubyApi.isKindOf(value, runtime.getModule("Date"))) {
-            return quote_string_with_surround(runtime, "'", RubyString.objAsString(value), "'"); 
+            return quote_string_with_surround(runtime, "'", RubyString.objAsString(context, value), "'");
         } else if (rubyApi.isKindOf(value, runtime.getModule("Time")) || rubyApi.isKindOf(value, runtime.getModule("DateTime"))) {
             return quote_string_with_surround(runtime, "'", (RubyString)(rubyApi.callMethod(recv, "quoted_date", value)), "'"); 
         } else {
@@ -182,7 +175,7 @@ public class JdbcDerbySpec {
 
     private final static ByteList TWO_SINGLE = new ByteList(new byte[]{'\'','\''});
 
-    public static IRubyObject quote_string_with_surround(Ruby runtime, String before, RubyString string, String after) {
+    private static IRubyObject quote_string_with_surround(Ruby runtime, String before, RubyString string, String after) {
         ByteList input = string.getByteList();
         ByteList output = new ByteList(before.getBytes());
         for(int i = input.begin; i< input.begin + input.realSize; i++) {
@@ -203,7 +196,7 @@ public class JdbcDerbySpec {
 
     private final static byte[] HEX = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
 
-    public static IRubyObject hexquote_string_with_surround(Ruby runtime, String before, RubyString string, String after) {
+    private static IRubyObject hexquote_string_with_surround(Ruby runtime, String before, RubyString string, String after) {
         ByteList input = string.getByteList();
         ByteList output = new ByteList(before.getBytes());
         for(int i = input.begin; i< input.begin + input.realSize; i++) {
@@ -232,6 +225,7 @@ public class JdbcDerbySpec {
         return true;
     }
 
+    @JRubyMethod(name = "quote_string", required = 1)
     public static IRubyObject quote_string(IRubyObject recv, IRubyObject string) {
         boolean replacementFound = false;
         ByteList bl = ((RubyString) string).getByteList();
@@ -259,10 +253,12 @@ public class JdbcDerbySpec {
         }
     }
 
+    @JRubyMethod(name = "select_all", rest = true)
     public static IRubyObject select_all(IRubyObject recv, IRubyObject[] args) {
         return rubyApi.callMethod(recv, "execute", args);
     }
 
+    @JRubyMethod(name = "select_one", rest = true)
     public static IRubyObject select_one(IRubyObject recv, IRubyObject[] args) {
         IRubyObject limit = rubyApi.getInstanceVariable(recv, "@limit");
         if (limit == null || limit.isNil()) {
@@ -276,6 +272,7 @@ public class JdbcDerbySpec {
         }
     }
 
+    @JRubyMethod(name = "add_limit_offset!", required = 2)
     public static IRubyObject add_limit_offset(IRubyObject recv, IRubyObject sql, IRubyObject options) {
         IRubyObject limit = rubyApi.callMethod(options, "[]", recv.getRuntime().newSymbol("limit"));
         rubyApi.setInstanceVariable(recv, "@limit",limit);
@@ -283,7 +280,8 @@ public class JdbcDerbySpec {
         return rubyApi.setInstanceVariable(recv, "@offset",offset);
     }
 
-    public static IRubyObject _execute(IRubyObject recv, IRubyObject[] args) throws SQLException, java.io.IOException {
+    @JRubyMethod(name = "_execute", required = 1, optional = 1)
+    public static IRubyObject _execute(ThreadContext context, IRubyObject recv, IRubyObject[] args) throws SQLException, java.io.IOException {
         Ruby runtime = recv.getRuntime();
         try {
             IRubyObject conn = rubyApi.getInstanceVariable(recv, "@connection");
@@ -302,11 +300,11 @@ public class JdbcDerbySpec {
                 IRubyObject range;
                 IRubyObject max;
                 if (limit == null || limit.isNil() || RubyNumeric.fix2int(limit) == -1) {
-                    range = RubyRange.newRange(runtime, offset, runtime.newFixnum(-1), false);
+                    range = RubyRange.newRange(runtime, context, offset, runtime.newFixnum(-1), false);
                     max = RubyFixnum.zero(runtime);
                 } else {
                     IRubyObject v1 = rubyApi.callMethod(offset, "+", limit);
-                    range = RubyRange.newRange(runtime, offset, v1, true);
+                    range = RubyRange.newRange(runtime, context, offset, v1, true);
                     max = rubyApi.callMethod(v1, "+", RubyFixnum.one(runtime));
                 }
                 IRubyObject result = JdbcAdapterInternalService.execute_query(conn, new IRubyObject[]{args[0], max});

data/src/java/jdbc_adapter/JdbcMySQLSpec.java

@@ -28,16 +28,15 @@ import org.jruby.Ruby;
 import org.jruby.RubyModule;
 import org.jruby.RubyString;
 
-import org.jruby.runtime.CallbackFactory;
+import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.builtin.IRubyObject;
 
 import org.jruby.util.ByteList;
 
 public class JdbcMySQLSpec {
-    public static void load(Ruby runtime, RubyModule jdbcSpec) {
+    public static void load(RubyModule jdbcSpec) {
         RubyModule mysql = jdbcSpec.defineModuleUnder("MySQL");
-        CallbackFactory cf = runtime.callbackFactory(JdbcMySQLSpec.class);
-        mysql.defineFastMethod("quote_string",cf.getFastSingletonMethod("quote_string",IRubyObject.class));
+        mysql.defineAnnotatedMethods(JdbcMySQLSpec.class);
     }
 
     private final static ByteList ZERO = new ByteList(new byte[]{'\\','0'});
@@ -48,9 +47,11 @@ public class JdbcMySQLSpec {
     private final static ByteList SINGLE = new ByteList(new byte[]{'\\','\''});
     private final static ByteList ESCAPE = new ByteList(new byte[]{'\\','\\'});
 
+    @JRubyMethod(name = "quote_string", required = 1)
     public static IRubyObject quote_string(IRubyObject recv, IRubyObject string) {
-        boolean replacementFound = false;
         ByteList bl = ((RubyString) string).getByteList();
+        ByteList blNew = new ByteList();
+        int startOfExtend = bl.begin;
         
         for(int i = bl.begin; i < bl.begin + bl.realSize; i++) {
             ByteList rep = null;
@@ -64,23 +65,18 @@ public class JdbcMySQLSpec {
             case '\\': rep = ESCAPE; break;
             default: continue;
             }
-            
-            // On first replacement allocate a different bytelist so we don't manip original 
-            if(!replacementFound) {
-                i-= bl.begin;
-                bl = new ByteList(bl);
-                replacementFound = true;
-            }
-
-            bl.replace(i, 1, rep);
-            i+=1;
+            if(i > startOfExtend)
+              blNew.append(bl, startOfExtend, i-startOfExtend);
+            blNew.append(rep, 0, 2);
+            startOfExtend = i+1;
         }
-
-        if(!replacementFound) {
-            return string;
+        // Nothing changed, can return original
+        if (startOfExtend == bl.begin) {
+          return string;
         }
+        if (bl.begin + bl.realSize > startOfExtend)
+          blNew.append(bl, startOfExtend, bl.begin + bl.realSize - startOfExtend);
 
-
-        return recv.getRuntime().newStringShared(bl);
+        return recv.getRuntime().newStringShared(blNew);
     }
 }

data/test/db/derby.rb

@@ -13,6 +13,5 @@ ActiveRecord::Base.logger = logger
 at_exit {  
   # Clean up derby files
   require 'fileutils'
-  Dir.glob('derby-testdb/**/*') {|f| File.delete(f)}
   FileUtils.rm_rf('derby-testdb')
 }

data/test/models/reserved_word.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'active_record'
+
+class CreateReservedWords < ActiveRecord::Migration
+  def self.up
+    create_table "reserved_words", :force => true do |t|
+      t.column :position, :integer
+      t.column :select, :integer
+    end
+  end
+
+  def self.down
+    drop_table "reserved_words"
+  end
+end
+
+class ReservedWord < ActiveRecord::Base
+end

data/test/postgres_reserved_test.rb

@@ -0,0 +1,22 @@
+require 'jdbc_common'
+require 'db/postgres'
+require 'models/reserved_word'
+
+class PostgresReservedWordsTest < Test::Unit::TestCase
+  def setup
+    CreateReservedWords.up
+  end
+  def teardown
+    CreateReservedWords.down
+  end
+
+  def test_quote_reserved_word_column
+    columns = ReservedWord.column_names - ["id"]
+    ReservedWord.connection.add_index :reserved_words, columns
+    indexes = ReservedWord.connection.indexes("reserved_words")
+    assert_equal 1, indexes.size
+    columns.each do |c|
+      assert indexes[0].columns.include?(c), "#{indexes[0].columns.inspect} does not include #{c.inspect}"
+    end
+  end
+end

data/test/simple.rb

@@ -87,7 +87,7 @@ module SimpleTestMethods
         
       indexes = @connection.indexes(:entries)
       assert_equal(1, indexes.size)
-      assert_equal "entries", indexes.first.table
+      assert_equal "entries", indexes.first.table.to_s
       assert_equal index_name, indexes.first.name
       assert !indexes.first.unique
       assert_equal ["updated_on"], indexes.first.columns

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-jdbc-adapter
 version: !ruby/object:Gem::Version 
-  version: 0.7.2
+  version: "0.8"
 platform: ruby
 authors: 
 - Nick Sieger, Ola Bini and JRuby contributors
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-12 00:00:00 -06:00
+date: 2008-03-19 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -23,12 +23,13 @@ extra_rdoc_files:
 - History.txt
 - Manifest.txt
 - README.txt
+- LICENSE.txt
 files: 
 - History.txt
 - Manifest.txt
 - README.txt
 - Rakefile
-- LICENSE
+- LICENSE.txt
 - lib/active_record/connection_adapters/derby_adapter.rb
 - lib/active_record/connection_adapters/h2_adapter.rb
 - lib/active_record/connection_adapters/hsqldb_adapter.rb
@@ -86,11 +87,14 @@ files:
 - test/models/auto_id.rb
 - test/models/data_types.rb
 - test/models/entry.rb
+- test/models/reserved_word.rb
 - test/mysql_multibyte_test.rb
 - test/mysql_simple_test.rb
 - test/oracle_simple_test.rb
+- test/postgres_reserved_test.rb
 - test/postgres_simple_test.rb
 - test/simple.rb
+- lib/jdbc_adapter/jdbc.rake
 - src/java/jdbc_adapter/JdbcAdapterInternalService.java
 - src/java/jdbc_adapter/JdbcConnectionFactory.java
 - src/java/jdbc_adapter/JdbcDerbySpec.java