sequel 3.21.0 → 3.39.0

data/lib/sequel/adapters/jdbc.rb

@@ -32,47 +32,96 @@ module Sequel
     DATABASE_SETUP = {:postgresql=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/postgresql'
         db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Postgres::Dataset
         JDBC.load_gem('postgres')
         org.postgresql.Driver
       end,
       :mysql=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/mysql'
         db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
+        db.extend_datasets Sequel::MySQL::DatasetMethods
         JDBC.load_gem('mysql')
         com.mysql.jdbc.Driver
       end,
       :sqlite=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/sqlite'
         db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
+        db.extend_datasets Sequel::SQLite::DatasetMethods
+        db.set_integer_booleans
         JDBC.load_gem('sqlite3')
         org.sqlite.JDBC
       end,
       :oracle=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/oracle'
         db.extend(Sequel::JDBC::Oracle::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Oracle::Dataset
         Java::oracle.jdbc.driver.OracleDriver
       end,
       :sqlserver=>proc do |db|
-        Sequel.ts_require 'adapters/jdbc/mssql'
-        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        Sequel.ts_require 'adapters/jdbc/sqlserver'
+        db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
+        db.extend_datasets Sequel::MSSQL::DatasetMethods
+        db.send(:set_mssql_unicode_strings)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
       end,
       :jtds=>proc do |db|
-        Sequel.ts_require 'adapters/jdbc/mssql'
-        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        Sequel.ts_require 'adapters/jdbc/jtds'
+        db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::JTDS::Dataset
+        db.send(:set_mssql_unicode_strings)
         JDBC.load_gem('jtds')
         Java::net.sourceforge.jtds.jdbc.Driver
       end,
       :h2=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/h2'
         db.extend(Sequel::JDBC::H2::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::H2::Dataset
         JDBC.load_gem('h2')
         org.h2.Driver
       end,
+      :hsqldb=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/hsqldb'
+        db.extend(Sequel::JDBC::HSQLDB::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::HSQLDB::Dataset
+        # Current gem is 1.8.1.3, but Sequel supports 2.2.5
+        org.hsqldb.jdbcDriver
+      end,
+      :derby=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/derby'
+        db.extend(Sequel::JDBC::Derby::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Derby::Dataset
+        JDBC.load_gem('derby')
+        org.apache.derby.jdbc.EmbeddedDriver
+      end,
       :as400=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/as400'
         db.extend(Sequel::JDBC::AS400::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::AS400::Dataset
         com.ibm.as400.access.AS400JDBCDriver
+      end,
+      :"informix-sqli"=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/informix'
+        db.extend(Sequel::JDBC::Informix::DatabaseMethods)
+        db.extend_datasets Sequel::Informix::DatasetMethods
+        com.informix.jdbc.IfxDriver
+      end,
+      :db2=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/db2'
+        db.extend(Sequel::JDBC::DB2::DatabaseMethods)
+        db.extend_datasets Sequel::DB2::DatasetMethods
+        com.ibm.db2.jcc.DB2Driver
+      end,
+      :firebirdsql=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/firebird'
+        db.extend(Sequel::JDBC::Firebird::DatabaseMethods)
+        db.extend_datasets Sequel::Firebird::DatasetMethods
+        org.firebirdsql.jdbc.FBDriver
+      end,
+      :jdbcprogress=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/progress'
+        db.extend(Sequel::JDBC::Progress::DatabaseMethods)
+        db.extend_datasets Sequel::Progress::DatasetMethods
+        com.progress.sql.jdbc.JdbcProgressDriver
       end
     }
     
@@ -101,13 +150,15 @@ module Sequel
       # True by default, can be set to false to roughly double performance when
       # fetching rows.
       attr_accessor :convert_types
-      
+
       # Call the DATABASE_SETUP proc directly after initialization,
       # so the object always uses sub adapter specific code.  Also,
       # raise an error immediately if the connection doesn't have a
       # uri, since JDBC requires one.
       def initialize(opts)
         super
+        @connection_prepared_statements = {}
+        @connection_prepared_statements_mutex = Mutex.new
         @convert_types = typecast_value_boolean(@opts.fetch(:convert_types, true))
         raise(Error, "No connection string specified") unless uri
         
@@ -158,8 +209,9 @@ module Sequel
           args = [uri(opts)]
           args.concat([opts[:user], opts[:password]]) if opts[:user] && opts[:password]
           begin
+            JavaSQL::DriverManager.setLoginTimeout(opts[:login_timeout]) if opts[:login_timeout]
             JavaSQL::DriverManager.getConnection(*args)
-          rescue => e
+          rescue JavaSQL::SQLException, NativeException, StandardError => e
             raise e unless driver
             # If the DriverManager can't get the connection - use the connect
             # method of the driver. (This happens under Tomcat for instance)
@@ -170,8 +222,10 @@ module Sequel
             end
             opts[:jdbc_properties].each{|k,v| props.setProperty(k.to_s, v)} if opts[:jdbc_properties]
             begin
-              driver.new.connect(args[0], props)
-            rescue => e2
+              c = driver.new.connect(args[0], props)
+              raise(Sequel::DatabaseError, 'driver.new.connect returned nil: probably bad JDBC connection string') unless c
+              c
+            rescue JavaSQL::SQLException, NativeException, StandardError => e2
               e.message << "\n#{e2.class.name}: #{e2.message}"
               raise e
             end
@@ -180,11 +234,6 @@ module Sequel
         setup_connection(conn)
       end
       
-      # Return instances of JDBC::Dataset with the given opts.
-      def dataset(opts = nil)
-        JDBC::Dataset.new(self, opts)
-      end
-      
       # Execute the given SQL.  If a block is given, if should be a SELECT
       # statement or something else that returns rows.
       def execute(sql, opts={}, &block)
@@ -246,12 +295,14 @@ module Sequel
         indexes
       end 
 
+      # Whether or not JNDI is being used for this connection.
+      def jndi?
+        !!(uri =~ JNDI_URI_REGEXP)
+      end
+      
       # All tables in this database
       def tables(opts={})
-        ts = []
-        m = output_identifier_meth
-        metadata(:getTables, nil, nil, nil, ['TABLE'].to_java(:string)){|h| ts << m.call(h[:table_name])}
-        ts
+        get_tables('TABLE', opts)
       end
       
       # The uri for this connection.  You can specify the uri
@@ -264,18 +315,31 @@ module Sequel
         ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
       end
 
-      # Whether or not JNDI is being used for this connection.
-      def jndi?
-        !!(uri =~ JNDI_URI_REGEXP)
+      # All views in this database
+      def views(opts={})
+        get_tables('VIEW', opts)
       end
-      
+
       private
          
-      # Close given adapter connections
+      # Yield the native prepared statements hash for the given connection
+      # to the block in a thread-safe manner.
+      def cps_sync(conn, &block)
+        @connection_prepared_statements_mutex.synchronize{yield(@connection_prepared_statements[conn] ||= {})}
+      end
+
+      # Close given adapter connections, and delete any related prepared statements.
       def disconnect_connection(c)
+        @connection_prepared_statements_mutex.synchronize{@connection_prepared_statements.delete(c)}
         c.close
       end
       
+      # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
+      def disconnect_error?(exception, opts)
+        cause = exception.respond_to?(:cause) ? exception.cause : exception
+        super || (cause.respond_to?(:getSQLState) && cause.getSQLState =~ /^08/)
+      end
+
       # Execute the prepared statement.  If the provided name is a
       # dataset, use that as the prepared statement, otherwise use
       # it as a key to look it up in the prepared_statements hash.
@@ -289,20 +353,25 @@ module Sequel
           ps = name
           name = ps.prepared_statement_name
         else
-          ps = prepared_statements[name]
+          ps = prepared_statement(name)
         end
         sql = ps.prepared_sql
         synchronize(opts[:server]) do |conn|
-          if name and cps = conn.prepared_statements[name] and cps[0] == sql
+          if name and cps = cps_sync(conn){|cpsh| cpsh[name]} and cps[0] == sql
             cps = cps[1]
           else
-            log_yield("Closing #{name}"){cps[1].close} if cps
-            cps = log_yield("Preparing#{" #{name}:" if name} #{sql}"){conn.prepareStatement(sql)}
-            conn.prepared_statements[name] = [sql, cps] if name
+            log_yield("CLOSE #{name}"){cps[1].close} if cps
+            cps = log_yield("PREPARE#{" #{name}:" if name} #{sql}"){conn.prepareStatement(sql)}
+            cps_sync(conn){|cpsh| cpsh[name] = [sql, cps]} if name
           end
           i = 0
           args.each{|arg| set_ps_arg(cps, arg, i+=1)}
-          msg = "Executing#{" #{name}" if name}"
+          msg = "EXECUTE#{" #{name}" if name}"
+          if ps.log_sql
+            msg << " ("
+            msg << sql
+            msg << ")"
+          end
           begin
             if block_given?
               yield log_yield(msg, args){cps.executeQuery}
@@ -325,6 +394,12 @@ module Sequel
         end
       end
 
+      # Gets the connection from JNDI.
+      def get_connection_from_jndi
+        jndi_name = JNDI_URI_REGEXP.match(uri)[1]
+        JavaxNaming::InitialContext.new.lookup(jndi_name).connection
+      end
+            
       # Gets the JDBC connection uri from the JNDI resource.
       def get_uri_from_jndi
         conn = get_connection_from_jndi
@@ -333,12 +408,14 @@ module Sequel
         conn.close if conn
       end
       
-      # Gets the connection from JNDI.
-      def get_connection_from_jndi
-        jndi_name = JNDI_URI_REGEXP.match(uri)[1]
-        JavaxNaming::InitialContext.new.lookup(jndi_name).connection
+      # Backbone of the tables and views support.
+      def get_tables(type, opts)
+        ts = []
+        m = output_identifier_meth
+        metadata(:getTables, nil, nil, nil, [type].to_java(:string)){|h| ts << m.call(h[:table_name])}
+        ts
       end
-            
+
       # Support Date objects used in bound variables
       def java_sql_date(date)
         java.sql.Date.new(Time.local(date.year, date.month, date.day).to_i * 1000)
@@ -354,7 +431,8 @@ module Sequel
       # Support fractional seconds for Time objects used in bound variables
       def java_sql_timestamp(time)
         ts = java.sql.Timestamp.new(time.to_i * 1000)
-        ts.setNanos(RUBY_VERSION >= '1.9.0' ? time.nsec : time.usec * 1000)
+        # Work around jruby 1.6 ruby 1.9 mode bug
+        ts.setNanos((RUBY_VERSION >= '1.9.0' && time.nsec != 0) ? time.nsec : time.usec * 1000)
         ts
       end 
       
@@ -383,12 +461,6 @@ module Sequel
         end
       end
 
-      # Treat SQLExceptions with a "Connection Error" SQLState as disconnects
-      def raise_error(exception, opts={})
-        cause = exception.respond_to?(:cause) ? exception.cause : exception
-        super(exception, {:disconnect => cause.respond_to?(:getSQLState) && cause.getSQLState =~ /^08/}.merge(opts))
-      end
-
       # Java being java, you need to specify the type of each argument
       # for the prepared statement, and bind it individually.  This
       # guesses which JDBC method to use, and hopefully JRuby will convert
@@ -405,8 +477,8 @@ module Sequel
           cps.setDouble(i, arg)
         when TrueClass, FalseClass
           cps.setBoolean(i, arg)
-        when nil
-          cps.setNull(i, JavaSQL::Types::NULL)
+        when NilClass
+          set_ps_arg_nil(cps, i)
         when DateTime
           cps.setTimestamp(i, java_sql_datetime(arg))
         when Date
@@ -421,22 +493,22 @@ module Sequel
           cps.setObject(i, arg)
         end
       end
+
+      # Use setString with a nil value by default, but this doesn't work on all subadapters.
+      def set_ps_arg_nil(cps, i)
+        cps.setString(i, nil)
+      end
       
-      # Add a prepared_statements accessor to the connection,
-      # and set it to an empty hash.  This is used to store
-      # adapter specific prepared statements.
+      # Return the connection.  Used to do configuration on the
+      # connection object before adding it to the connection pool.
       def setup_connection(conn)
-        class << conn
-          attr_accessor :prepared_statements
-        end
-        conn.prepared_statements = {}
         conn
       end
       
       # Parse the table schema for the given table.
       def schema_parse_table(table, opts={})
-        m = output_identifier_meth
-        im = input_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
+        im = input_identifier_meth(opts[:dataset])
         ds = dataset
         schema, table = schema_and_table(table)
         schema ||= opts[:schema]
@@ -444,9 +516,11 @@ module Sequel
         table = im.call(table)
         pks, ts = [], []
         metadata(:getPrimaryKeys, nil, schema, table) do |h|
+          next if schema_parse_table_skip?(h, schema)
           pks << h[:column_name]
         end
         metadata(:getColumns, nil, schema, table, nil) do |h|
+          next if schema_parse_table_skip?(h, schema)
           s = {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name]), :column_size=>h[:column_size], :scale=>h[:decimal_digits]}
           if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
             s[:type] = :integer
@@ -456,6 +530,12 @@ module Sequel
         ts
       end
       
+      # Whether schema_parse_table should skip the given row when
+      # parsing the schema.
+      def schema_parse_table_skip?(h, schema)
+        h[:table_schem] == 'INFORMATION_SCHEMA'
+      end
+
       # Yield a new statement object, and ensure that it is closed before returning.
       def statement(conn)
         stmt = conn.createStatement
@@ -476,6 +556,8 @@ module Sequel
     
     class Dataset < Sequel::Dataset
       include StoredProcedures
+
+      Database::DatasetClass = self
       
       # Use JDBC PreparedStatements instead of emulated ones.  Statements
       # created using #prepare are cached at the connection level to allow
@@ -489,17 +571,17 @@ module Sequel
         # Execute the prepared SQL using the stored type and
         # arguments derived from the hash passed to call.
         def execute(sql, opts={}, &block)
-          super(self, {:arguments=>bind_arguments, :type=>sql_query_type}.merge(opts), &block)
+          super(self, {:arguments=>bind_arguments}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
         def execute_dui(sql, opts={}, &block)
-          super(self, {:arguments=>bind_arguments, :type=>sql_query_type}.merge(opts), &block)
+          super(self, {:arguments=>bind_arguments}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
         def execute_insert(sql, opts={}, &block)
-          super(self, {:arguments=>bind_arguments, :type=>sql_query_type}.merge(opts), &block)
+          super(self, {:arguments=>bind_arguments, :type=>:insert}.merge(opts), &block)
         end
       end
       
@@ -512,17 +594,17 @@ module Sequel
         
         # Execute the database stored procedure with the stored arguments.
         def execute(sql, opts={}, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true, :type=>sql_query_type}.merge(opts), &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
         def execute_dui(sql, opts={}, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true, :type=>sql_query_type}.merge(opts), &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
         def execute_insert(sql, opts={}, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true, :type=>sql_query_type}.merge(opts), &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true, :type=>:insert}.merge(opts), &block)
         end
       end
       
@@ -530,13 +612,7 @@ module Sequel
       # Uses the database's setting by default, can be set to false to roughly
       # double performance when fetching rows.
       attr_accessor :convert_types
-      
-      # Use the convert_types default setting from the database
-      def initialize(db, opts={})
-        @convert_types = db.convert_types
-        super
-      end
-      
+
       # Correctly return rows from the database and return them as hashes.
       def fetch_rows(sql, &block)
         execute(sql){|result| process_result_set(result, &block)}
@@ -550,32 +626,88 @@ module Sequel
         ps.extend(PreparedStatementMethods)
         if name
           ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
+          db.set_prepared_statement(name, ps)
         end
         ps
       end
       
       private
-      
-      # Convert the type.  Used for converting Java types to ruby types.
-      def convert_type(v)
+
+      # Cache Java class constants to speed up lookups
+      JAVA_SQL_TIMESTAMP    = Java::JavaSQL::Timestamp
+      JAVA_SQL_TIME         = Java::JavaSQL::Time
+      JAVA_SQL_DATE         = Java::JavaSQL::Date
+      JAVA_SQL_BLOB         = Java::JavaSQL::Blob
+      JAVA_SQL_CLOB         = Java::JavaSQL::Clob
+      JAVA_BUFFERED_READER  = Java::JavaIo::BufferedReader
+      JAVA_BIG_DECIMAL      = Java::JavaMath::BigDecimal
+      JAVA_BYTE_ARRAY       = Java::byte[]
+      JAVA_UUID             = Java::JavaUtil::UUID
+
+      # Handle type conversions for common Java types.
+      class TYPE_TRANSLATOR
+        LF = "\n".freeze
+        def time(v) Sequel.string_to_time("#{v.to_string}.#{sprintf('%03i', v.getTime.divmod(1000).last)}") end
+        def date(v) Date.civil(v.getYear + 1900, v.getMonth + 1, v.getDate) end
+        def decimal(v) BigDecimal.new(v.to_string) end
+        def byte_array(v) Sequel::SQL::Blob.new(String.from_java_bytes(v)) end
+        def blob(v) Sequel::SQL::Blob.new(String.from_java_bytes(v.getBytes(1, v.length))) end
+        def clob(v) Sequel::SQL::Blob.new(v.getSubString(1, v.length)) end
+        def buffered_reader(v)
+          lines = ""
+          c = false
+          while(line = v.read_line) do
+            lines << LF if c
+            lines << line
+            c ||= true
+          end
+          lines
+        end
+        def uuid(v) v.to_string end
+      end
+      TYPE_TRANSLATOR_INSTANCE = tt = TYPE_TRANSLATOR.new
+
+      # Cache type translator methods so that duplicate Method
+      # objects are not created.
+      DECIMAL_METHOD = tt.method(:decimal)
+      TIME_METHOD = tt.method(:time)
+      DATE_METHOD = tt.method(:date)
+      BUFFERED_READER_METHOD = tt.method(:buffered_reader)
+      BYTE_ARRAY_METHOD = tt.method(:byte_array)
+      BLOB_METHOD = tt.method(:blob)
+      CLOB_METHOD = tt.method(:clob)
+      UUID_METHOD = tt.method(:uuid)
+
+      # Convert the given Java timestamp to an instance of Sequel.datetime_class.
+      def convert_type_timestamp(v)
+        db.to_application_timestamp([v.getYear + 1900, v.getMonth + 1, v.getDate, v.getHours, v.getMinutes, v.getSeconds, v.getNanos])
+      end
+
+      # Return a callable object that will convert any value of <tt>v</tt>'s
+      # class to a ruby object.  If no callable object can handle <tt>v</tt>'s
+      # class, return false so that the negative lookup is cached.
+      def convert_type_proc(v)
         case v
-        when Java::JavaSQL::Timestamp, Java::JavaSQL::Time
-          Sequel.database_to_application_timestamp(v.to_string)
-        when Java::JavaSQL::Date
-          Sequel.string_to_date(v.to_string)
-        when Java::JavaIo::BufferedReader
-          lines = []
-          while(line = v.read_line) do lines << line end
-          lines.join("\n")
-        when Java::JavaMath::BigDecimal
-          BigDecimal.new(v.to_string)
-        when Java::byte[]
-          Sequel::SQL::Blob.new(String.from_java_bytes(v))
-        when Java::JavaSQL::Blob
-          convert_type(v.getBytes(1, v.length))
+        when JAVA_BIG_DECIMAL
+          DECIMAL_METHOD
+        when JAVA_SQL_TIMESTAMP
+          method(:convert_type_timestamp)
+        when JAVA_SQL_TIME
+          TIME_METHOD
+        when JAVA_SQL_DATE
+          DATE_METHOD
+        when JAVA_BUFFERED_READER
+          BUFFERED_READER_METHOD
+        when JAVA_BYTE_ARRAY
+          BYTE_ARRAY_METHOD
+        when JAVA_SQL_BLOB
+          BLOB_METHOD
+        when JAVA_SQL_CLOB
+          CLOB_METHOD
+        when JAVA_UUID
+          UUID_METHOD
         else
-          v
+          false
         end
       end
       
@@ -586,32 +718,82 @@ module Sequel
       
       # Split out from fetch rows to allow processing of JDBC result sets
       # that don't come from issuing an SQL string.
-      def process_result_set(result)
+      def process_result_set(result, &block)
         # get column names
         meta = result.getMetaData
         cols = []
         i = 0
         meta.getColumnCount.times{cols << [output_identifier(meta.getColumnLabel(i+=1)), i]}
-        @columns = cols.map{|c| c.at(0)}
-        blk = result_set_object_getter
-        # get rows
+        columns = cols.map{|c| c.at(0)}
+        if opts[:offset] && offset_returns_row_number_column?
+          rn = row_number_column
+          columns.delete(rn)
+        end
+        @columns = columns
+        ct = @convert_types
+        if (ct.nil? ? db.convert_types : ct)
+          cols.each{|c| c << nil}
+          process_result_set_convert(cols, result, rn, &block)
+        else
+          process_result_set_no_convert(cols, result, rn, &block)
+        end
+      ensure
+        result.close
+      end
+
+      # Use conversion procs to convert data retrieved
+      # from the database.  This has been optimized, the algorithm it uses
+      # is roughly, for each column value in each row:
+      # * check if the value is truthy (not false/nil)
+      # * if not truthy, return object
+      # * otherwise, see if a conversion method exists for
+      #   the column.  All columns start with a nil conversion proc,
+      #   since unlike other adapters, Sequel doesn't get the type of
+      #   the column when parsing the column metadata.
+      # * if a conversion proc is not false/nil, call it with the object
+      #   and return the result.
+      # * if a conversion proc has already been looked up and doesn't
+      #   exist (false value), return object.  
+      # * if a conversion proc hasn't been looked up yet (nil value),
+      #   call convert_type_proc to get the conversion method.  Cache
+      #   the result of as the column's conversion proc to speed up
+      #   later processing.  If the conversion proc exists, call it
+      #   and return the result, otherwise, return the object.
+      def process_result_set_convert(cols, result, rn)
         while result.next
           row = {}
-          cols.each do |n, i|
-            row[n] = blk.call(result, n, i)
+          cols.each do |n, i, p|
+            v = result.getObject(i)
+            row[n] = if v
+              if p
+                p.call(v)
+              elsif p.nil?
+                cols[i-1][2] = p = convert_type_proc(v)
+                if p
+                  p.call(v)
+                else
+                  v
+                end
+              else
+                v
+              end
+            else
+              v
+            end
           end
+          row.delete(rn) if rn
           yield row
         end
       end
 
-      # Proc that takes the ResultSet and an integer field number and returns
-      # the object for that field.  Respects the @convert_types setting to
-      # convert Java types to ruby types.
-      def result_set_object_getter
-        if @convert_types
-          lambda {|result, n, i| convert_type(result.getObject(i))}
-        else
-          lambda {|result, n, i| result.getObject(i)}
+      # Yield rows without calling any conversion procs.  This
+      # may yield Java values and not ruby values.
+      def process_result_set_no_convert(cols, result, rn)
+        while result.next
+          row = {}
+          cols.each{|n, i| row[n] = result.getObject(i)}
+          row.delete(rn) if rn
+          yield row
         end
       end
     end