sequel 5.8.0 → 5.38.0

data/doc/sql.rdoc

@@ -229,6 +229,18 @@ If the database supports window functions, Sequel can handle them by calling the
   DB[:albums].select{function(c1, c2).over(:partition=>[c3, c4], :order=>[c5, c6.desc])}
   # SELECT function(c1, c2) OVER (PARTITION BY c3, c4 ORDER BY c5, c6 DESC) FROM albums
 
+  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>:rows)}
+  # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM albums
+
+  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>1, :end=>1})}
+  # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM albums
+
+  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:groups, :start=>[2, :preceding], :end=>[1, :preceding]})}
+  # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 GROUPS BETWEEN 2 PRECEDING AND 1 PRECEDING) FROM albums
+
+  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>:preceding, :exclude=>:current})}
+  # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM albums
+
 === Schema Qualified Functions
 
 If the database supports schema qualified functions, Sequel can handle them by calling the +function+ method on a qualified identifier:

data/doc/testing.rdoc

@@ -8,34 +8,39 @@ These run each test in its own transaction, the recommended way to test.
 
 === minitest/spec
 
-==== with minitest-hooks
-
+==== with minitest-hooks    
   require 'minitest/hooks/default'
+  
+  DB = Sequel.postgres # change if using sqlite etc
+  
   class Minitest::HooksSpec
     def around
-      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
-==== without minitest-hooks
-
+==== without minitest-hooks  
+  DB = Sequel.postgres # change if using sqlite etc
+  
   class Minitest::Spec
     def run(*args, &block)
-      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
 === minitest/test
-
+  DB = Sequel.postgres # change if using sqlite etc
+  
   # Use this class as the base class for your tests
   class SequelTestCase < Minitest::Test
     def run(*args, &block)
-      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
 === rspec >= 2.8
-
+  DB = Sequel.postgres # change the database if you are using sqlite etc.
+  
   RSpec.configure do |c|
     c.around(:each) do |example|
       DB.transaction(:rollback=>:always, :auto_savepoint=>true){example.run}
@@ -46,7 +51,7 @@ These run each test in its own transaction, the recommended way to test.
 
 You can use the Sequel.transaction method to run a transaction on multiple databases, rolling all of them back.  Instead of:
 
-  Sequel::Model.db.transaction(:rollback=>:always)
+  DB.transaction(:rollback=>:always)
 
 Use Sequel.transaction with an array of databases:
 
@@ -66,11 +71,11 @@ Example:
   require 'minitest/hooks/default'
   class Minitest::HooksSpec
     def around
-      Sequel::Model.db.transaction(:rollback=>:always, :savepoint=>true, :auto_savepoint=>true){super}
+      DB.transaction(:rollback=>:always, :savepoint=>true, :auto_savepoint=>true){super}
     end
 
     def around_all
-      Sequel::Model.db.transaction(:rollback=>:always){super}
+      DB.transaction(:rollback=>:always){super}
     end
   end
 
@@ -90,9 +95,9 @@ The order in which you delete/truncate the tables is important if you are using
 
   describe "some test suite" do
     after do
-      [:table1, :table2].each{|x| Sequel::Model.db.from(x).truncate}
+      [:table1, :table2].each{|x| DB.from(x).truncate}
       # or
-      [:table1, :table2].each{|x| Sequel::Model.db.from(x).delete}
+      [:table1, :table2].each{|x| DB.from(x).delete}
     end
   end
 
@@ -100,9 +105,9 @@ The order in which you delete/truncate the tables is important if you are using
 
   class SomeTestClass < Minitest::Test
     def teardown
-      [:table1, :table2].each{|x| Sequel::Model.db.from(x).truncate}
+      [:table1, :table2].each{|x| DB.from(x).truncate}
       # or
-      [:table1, :table2].each{|x| Sequel::Model.db.from(x).delete}
+      [:table1, :table2].each{|x| DB.from(x).delete}
     end
   end
 
@@ -157,14 +162,16 @@ SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when runni
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_INDEX_CACHING :: Use the index_caching extension when running the specs
+SEQUEL_FIBER_CONCURRENCY :: Use the fiber_concurrency extension when running the adapter and integration specs
 SEQUEL_FREEZE_DATABASE :: Freeze the database before running the integration specs
 SEQUEL_IDENTIFIER_MANGLING :: Use the identifier_mangling extension when running the specs
 SEQUEL_INTEGER64 :: Use the integer64 extension when running the adapter or integration specs
 SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements plugin when running the specs
+SEQUEL_MODEL_THROW_FAILURES :: Use the throw_failures plugin when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
-SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the specs
 SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
 SEQUEL_PG_TIMESTAMPTZ :: Use the pg_timestamptz extension when running the postgres specs
 SEQUEL_SPLIT_SYMBOLS :: Turn on symbol splitting when running the adapter and integration specs
 SEQUEL_SYNCHRONIZE_SQL :: Use the synchronize_sql extension when running the specs
+SEQUEL_TZINFO_VERSION :: Force the given tzinfo version when running the specs (e.g. '>=2')

data/doc/transactions.rdoc

@@ -36,6 +36,12 @@ If any other exception is raised, the transaction is rolled back, and the except
   end # ROLLBACK
   # ArgumentError raised
 
+If you want the current transaction to be rolled back when the transaction block exits instead of being committed (even if an exception is not raised), use <tt>Database#rollback_on_exit</tt>
+
+  DB.transaction do # BEGIN
+    DB.rollback_on_exit
+  end # ROLLBACK
+
 If you want Sequel::Rollback exceptions to be reraised, use the <tt>rollback: :reraise</tt> option:
 
   DB.transaction(rollback: :reraise) do # BEGIN
@@ -121,6 +127,78 @@ Other exceptions, unless rescued inside the outer transaction block, will rollba
   end # ROLLBACK
   # ArgumentError raised
 
+If you want the current savepoint to be rolled back when the savepoint block exits instead of being committed (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>true)</tt>
+
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.rollback_on_exit(:savepoint=>true)
+    end # ROLLBACK TO SAVEPOINT
+  end # COMMIT
+
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.rollback_on_exit(:savepoint=>true)
+      end # ROLLBACK TO SAVEPOINT
+    end # RELEASE SAVEPOINT
+  end # COMMIT
+
+If you want the current savepoint and potentially enclosing savepoints to be rolled back when the savepoint blocks exit  (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>integer)</tt>
+
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.rollback_on_exit(:savepoint=>2)
+      end # ROLLBACK TO SAVEPOINT
+    end # ROLLBACK TO SAVEPOINT
+  end # COMMIT
+
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.rollback_on_exit(:savepoint=>3)
+      end # ROLLBACK TO SAVEPOINT
+    end # ROLLBACK TO SAVEPOINT
+  end # ROLLBACK
+
+=== Savepoint Hooks
+
+When using savepoints, you can use the +:savepoint+ option to +after_commit+ or +after_rollback+ to use a savepoint hook.  For +after_commit+, this will only run the hook after transaction commit if all enclosing savepoints are released (not rolled back). For +after_rollback+, this will run the hook after any enclosing savepoint is rolled back (before transaction commit), or after the transaction is rolled back if all enclosing savepoints are released:
+
+  x = nil
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.after_commit(savepoint: true){x = 1}
+      DB.after_rollback(savepoint: true){x = 2}
+      x # nil
+    end # RELEASE SAVEPOINT
+    x # nil
+  end # COMMIT
+  x # 1
+  
+  x = nil
+  DB.transaction do  # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.after_commit(savepoint: true){x = 1}
+      DB.after_rollback(savepoint: true){x = 2}
+      x # nil
+      raise Sequel::Rollback
+    end # ROLLBACK TO SAVEPOINT
+    x # 2
+  end # COMMIT
+  x # 2
+  
+  x = nil
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.after_commit(savepoint: true){x = 1}
+      DB.after_rollback(savepoint: true){x = 2}
+    end # RELEASE SAVEPOINT
+    x # nil
+    raise Sequel::Rollback
+  end
+  x # 2
+
 == Prepared Transactions / Two-Phase Commit
 
 Sequel supports database prepared transactions on PostgreSQL, MySQL, and H2.  With prepared transactions, at the end of the transaction, the transaction is not immediately committed (it acts like a rollback).  Later, you can call +commit_prepared_transaction+ to commit the transaction or +rollback_prepared_transaction+ to roll the transaction back.  Prepared transactions are usually used with distributed databases to make sure all databases commit the same transaction or none of them do.

data/doc/validations.rdoc

@@ -232,7 +232,7 @@ These methods check that the specified attributes can be valid integers or valid
 
 === +validates_operator+
 
-+validates_operator+ checks that a given +operator+ method returns a truthy value when called on attribute with a specified value for comparison.  Generally, this is used for inequality checks (>, >=, etc) but any method that can be called on the attribute that accepts an argument and returns a truthy value may be used.
++validates_operator+ checks that a given +operator+ method returns a truthy value when called on attribute with a specified value for comparison.  Generally, this is used for inequality checks (>, >=, etc.) but any method that can be called on the attribute that accepts an argument and returns a truthy value may be used.
 
   class Album < Sequel::Model
     def validate
@@ -535,7 +535,7 @@ Note that the column names used in the errors are used verbatim in the error mes
   errors.full_messages
   # => ["Album name is not valid"]
 
-Alternatively, feel free to override Sequel::Model::Errors#full_messages.  As long as it returns an array of strings, overridding it is completely safe.
+Alternatively, feel free to override Sequel::Model::Errors#full_messages.  As long as it returns an array of strings, overriding it is completely safe.
 
 === +count+
 

data/lib/sequel/adapters/ado.rb

@@ -47,34 +47,40 @@ module Sequel
     #AdVarWChar         = 202
     #AdWChar            = 130
 
-    cp = Object.new
-
-    def cp.bigint(v)
+    bigint = Object.new
+    def bigint.call(v)
       v.to_i
     end
 
-    def cp.numeric(v)
-      BigDecimal.new(v)
+    numeric = Object.new
+    def numeric.call(v)
+      if v.include?(',')
+        BigDecimal(v.tr(',', '.'))
+      else
+        BigDecimal(v)
+      end
     end
 
-    def cp.binary(v)
+    binary = Object.new
+    def binary.call(v)
       Sequel.blob(v.pack('c*'))
     end
 
-    def cp.date(v)
+    date = Object.new
+    def date.call(v)
       Date.new(v.year, v.month, v.day)
     end
 
     CONVERSION_PROCS = {}
     [
-      [:bigint, AdBigInt],
-      [:numeric, AdNumeric, AdVarNumeric],
-      [:date, AdDBDate],
-      [:binary, AdBinary, AdVarBinary, AdLongVarBinary]
-    ].each do |meth, *types|
-      method = cp.method(meth)
+      [bigint, AdBigInt],
+      [numeric, AdNumeric, AdVarNumeric],
+      [date, AdDBDate],
+      [binary, AdBinary, AdVarBinary, AdLongVarBinary]
+    ].each do |callable, *types|
+      callable.freeze
       types.each do |i|
-        CONVERSION_PROCS[i] = method
+        CONVERSION_PROCS[i] = callable
       end
     end
     CONVERSION_PROCS.freeze
@@ -227,7 +233,6 @@ module Sequel
           cols = []
           conversion_procs = db.conversion_procs
 
-          i = -1
           ts_cp = nil
           recordset.Fields.each do |field|
             type = field.Type
@@ -244,18 +249,21 @@ module Sequel
             else
               conversion_procs[type]
             end
-            cols << [output_identifier(field.Name), cp, i+=1]
+            cols << [output_identifier(field.Name), cp]
           end
 
           self.columns = cols.map(&:first)
           return if recordset.EOF
+          max = cols.length
 
           recordset.GetRows.transpose.each do |field_values|
             h = {}
 
-            cols.each do |name, cp, i|
+            i = -1
+            while (i += 1) < max
+              name, cp = cols[i]
               h[name] = if (v = field_values[i]) && cp
-                cp[v]
+                cp.call(v)
               else
                 v
               end

data/lib/sequel/adapters/ado/access.rb

@@ -111,7 +111,7 @@ module Sequel
               log_connection_yield(sql, conn){conn.Execute(sql)}
               last_insert_sql = "SELECT @@IDENTITY"
               res = log_connection_yield(last_insert_sql, conn){conn.Execute(last_insert_sql)}
-              res.getRows.transpose.each{|r| return r.shift}
+              res.GetRows.transpose.each{|r| return r.shift}
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)
             end
@@ -296,7 +296,7 @@ module Sequel
           execute_open_ado_schema(type, criteria) do |s|
             cols = []
             s.Fields.each{|f| cols << f.Name}
-            s.getRows.transpose.each do |r|
+            s.GetRows.transpose.each do |r|
               row = {}
               cols.each{|c| row[c] = r.shift}
               yield row

data/lib/sequel/adapters/ado/mssql.rb

@@ -7,17 +7,14 @@ module Sequel
     module MSSQL
       module DatabaseMethods
         include Sequel::MSSQL::DatabaseMethods
-        # Issue a separate query to get the rows modified.  ADO appears to
-        # use pass by reference with an integer variable, which is
-        # not supported directly in ruby, and I'm not aware of a workaround.
+
         def execute_dui(sql, opts=OPTS)
           return super unless @opts[:provider]
           synchronize(opts[:server]) do |conn|
             begin
-              log_connection_yield(sql, conn){conn.Execute(sql)}
-              rows_affected_sql = "SELECT @@ROWCOUNT AS AffectedRows"
-              res = log_connection_yield(rows_affected_sql, conn){conn.Execute(rows_affected_sql)}
-              res.getRows.transpose.each{|r| return r.shift}
+              sql = "SET NOCOUNT ON; #{sql}; SELECT @@ROWCOUNT"
+              rst = log_connection_yield(sql, conn){conn.Execute(sql)}
+              rst.GetRows[0][0]
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)
             end
@@ -50,7 +47,7 @@ module Sequel
         # is necessary as ADO's default :provider uses a separate native
         # connection for each query.
         def insert(*values)
-          return super if @opts[:sql] || @opts[:returning]
+          return super if (@opts[:sql] && !@opts[:prepared_sql]) || @opts[:returning]
           with_sql("SET NOCOUNT ON; #{insert_sql(*values)}; SELECT CAST(SCOPE_IDENTITY() AS INTEGER)").single_value
         end
         

data/lib/sequel/adapters/amalgalite.rb

@@ -30,7 +30,7 @@ module Sequel
       # Return numeric/decimal types as instances of BigDecimal
       # instead of Float
       def decimal(s)
-        BigDecimal.new(s)
+        BigDecimal(s)
       end
       
       # Return datetime types as instances of Sequel.datetime_class

data/lib/sequel/adapters/jdbc.rb

@@ -17,7 +17,19 @@ module Sequel
     # Contains procs keyed on subadapter type that extend the
     # given database object so it supports the correct database type.
     DATABASE_SETUP = {}
+
+    # Create custom NativeException alias for nicer access, and also so that
+    # JRuby 9.2+ so it doesn't use the deprecated ::NativeException
+    NativeException = java.lang.Exception
     
+    # Default database error classes
+    DATABASE_ERROR_CLASSES = [NativeException]
+    if JRUBY_VERSION < '9.2'
+      # On JRuby <9.2, still include ::NativeException, as it is still needed in some cases
+      DATABASE_ERROR_CLASSES << ::NativeException
+    end
+    DATABASE_ERROR_CLASSES.freeze
+
     # Allow loading the necessary JDBC support via a gem.
     def self.load_gem(name)
       begin
@@ -39,55 +51,80 @@ module Sequel
     # Raise a Sequel::AdapterNotFound if evaluating the class name raises a NameError.
     def self.load_driver(drv, gem=nil)
       load_gem(gem) if gem
-      eval drv
+      if drv.is_a?(String)
+        eval drv
+      else
+        *try, last = drv
+        try.each do |try_drv|
+          begin
+            return eval(try_drv)
+          rescue NameError
+          end
+        end
+
+        eval last
+      end
     rescue NameError
       raise Sequel::AdapterNotFound, "#{drv} not loaded#{", try installing jdbc-#{gem.to_s.downcase} gem" if gem}"
     end
 
     class TypeConvertor
+      CONVERTORS = convertors = {}
       %w'Boolean Float Double Int Long Short'.each do |meth|
-        class_eval("def #{meth}(r, i) v = r.get#{meth}(i); v unless r.wasNull end", __FILE__, __LINE__)
+        x = convertors[meth.to_sym] = Object.new
+        class_eval("def x.call(r, i) v = r.get#{meth}(i); v unless r.wasNull end", __FILE__, __LINE__)
       end
       %w'Object Array String Time Date Timestamp BigDecimal Blob Bytes Clob'.each do |meth|
-        class_eval("def #{meth}(r, i) r.get#{meth}(i) end", __FILE__, __LINE__)
+        x = convertors[meth.to_sym] = Object.new
+        class_eval("def x.call(r, i) r.get#{meth}(i) end", __FILE__, __LINE__)
       end
-      def RubyTime(r, i)
+      x = convertors[:RubyTime] = Object.new
+      def x.call(r, i)
         if v = r.getTime(i)
           Sequel.string_to_time("#{v.to_string}.#{sprintf('%03i', v.getTime.divmod(1000).last)}")
         end
       end
-      def RubyDate(r, i)
+      x = convertors[:RubyDate] = Object.new
+      def x.call(r, i)
         if v = r.getDate(i)
           Date.civil(v.getYear + 1900, v.getMonth + 1, v.getDate)
         end
       end
-      def RubyTimestamp(r, i)
+      x = convertors[:RubyTimestamp] = Object.new
+      def x.call(r, i)
         if v = r.getTimestamp(i)
           Sequel.database_to_application_timestamp([v.getYear + 1900, v.getMonth + 1, v.getDate, v.getHours, v.getMinutes, v.getSeconds, v.getNanos])
         end
       end
-      def RubyBigDecimal(r, i)
+      x = convertors[:RubyBigDecimal] = Object.new
+      def x.call(r, i)
         if v = r.getBigDecimal(i)
-          BigDecimal.new(v.to_string)
+          ::Kernel::BigDecimal(v.to_string)
         end
       end
-      def RubyBlob(r, i)
+      x = convertors[:RubyBlob] = Object.new
+      def x.call(r, i)
         if v = r.getBytes(i)
           Sequel::SQL::Blob.new(String.from_java_bytes(v))
         end
       end
-      def RubyClob(r, i)
+      x = convertors[:RubyClob] = Object.new
+      def x.call(r, i)
         if v = r.getClob(i)
           v.getSubString(1, v.length)
         end
       end
+      x = convertors[:RubyArray] = Object.new
+      def x.call(r, i)
+        if v = r.getArray(i)
+          v.array.to_ary
+        end
+      end 
 
-      o = new
-      MAP = Hash.new(o.method(:Object))
+      MAP = Hash.new(convertors[:Object])
       types = Java::JavaSQL::Types
 
       {
-        :ARRAY => :Array,
         :BOOLEAN => :Boolean,
         :CHAR => :String,
         :DOUBLE => :Double,
@@ -101,11 +138,12 @@ module Sequel
         :TINYINT => :Short,
         :VARCHAR => :String,
       }.each do |type, meth|
-        MAP[types.const_get(type)] = o.method(meth) 
+        MAP[types.const_get(type)] = convertors[meth]
       end
       BASIC_MAP = MAP.dup
 
       {
+        :ARRAY => :Array,
         :BINARY => :Blob,
         :BLOB => :Blob,
         :CLOB => :Clob,
@@ -118,13 +156,11 @@ module Sequel
         :TIMESTAMP => :Timestamp,
         :VARBINARY => :Blob,
       }.each do |type, meth|
-        BASIC_MAP[types.const_get(type)] = o.method(meth) 
-        MAP[types.const_get(type)] = o.method(:"Ruby#{meth}") 
+        BASIC_MAP[types.const_get(type)] = convertors[meth]
+        MAP[types.const_get(type)] = convertors[:"Ruby#{meth}"]
       end
-
       MAP.freeze
       BASIC_MAP.freeze
-      freeze
     end
 
     class Database < Sequel::Database
@@ -168,7 +204,7 @@ module Sequel
                 last_insert_id(conn, opts)
               end
             end
-          rescue NativeException, JavaSQL::SQLException => e
+          rescue *DATABASE_ERROR_CLASSES => e
             raise_error(e)
           ensure
             cps.close
@@ -189,7 +225,7 @@ module Sequel
             JavaSQL::DriverManager.setLoginTimeout(opts[:login_timeout]) if opts[:login_timeout]
             raise StandardError, "skipping regular connection" if opts[:jdbc_properties]
             JavaSQL::DriverManager.getConnection(*args)
-          rescue JavaSQL::SQLException, NativeException, StandardError => e
+          rescue StandardError, *DATABASE_ERROR_CLASSES => 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)
@@ -203,7 +239,7 @@ module Sequel
               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
+            rescue StandardError, *DATABASE_ERROR_CLASSES => e2
               if e2.respond_to?(:message=) && e2.message != e.message
                 e2.message = "#{e2.message}\n#{e.class.name}: #{e.message}"
               end
@@ -236,7 +272,9 @@ module Sequel
                 log_connection_yield(sql, conn){stmt.execute(sql)}
               when :insert
                 log_connection_yield(sql, conn){execute_statement_insert(stmt, sql)}
-                last_insert_id(conn, Hash[opts].merge!(:stmt=>stmt))
+                opts = Hash[opts]
+                opts[:stmt] = stmt
+                last_insert_id(conn, opts)
               else
                 log_connection_yield(sql, conn){stmt.executeUpdate(sql)}
               end
@@ -355,7 +393,7 @@ module Sequel
       end
 
       def database_error_classes
-        [NativeException]
+        DATABASE_ERROR_CLASSES
       end
 
       def database_exception_sqlstate(exception, opts)
@@ -431,12 +469,15 @@ module Sequel
                 log_connection_yield(msg, conn, args){cps.execute}
               when :insert
                 log_connection_yield(msg, conn, args){execute_prepared_statement_insert(cps)}
-                last_insert_id(conn, Hash[opts].merge!(:prepared=>true, :stmt=>cps))
+                opts = Hash[opts]
+                opts[:prepared] = true
+                opts[:stmt] = cps
+                last_insert_id(conn, opts)
               else
                 log_connection_yield(msg, conn, args){cps.executeUpdate}
               end
             end
-          rescue NativeException, JavaSQL::SQLException => e
+          rescue *DATABASE_ERROR_CLASSES => e
             raise_error(e)
           ensure
             cps.close unless name
@@ -661,7 +702,7 @@ module Sequel
       def statement(conn)
         stmt = conn.createStatement
         yield stmt
-      rescue NativeException, JavaSQL::SQLException => e
+      rescue *DATABASE_ERROR_CLASSES => e
         raise_error(e)
       ensure
         stmt.close if stmt
@@ -773,11 +814,14 @@ module Sequel
           i += 1
           cols << [output_identifier(meta.getColumnLabel(i)), i, convert ? type_convertor(map, meta, meta.getColumnType(i), i) : basic_type_convertor(map, meta, meta.getColumnType(i), i)]
         end
+        max = i
         self.columns = cols.map{|c| c[0]}
 
         while result.next
           row = {}
-          cols.each do |n, j, pr|
+          i = -1
+          while (i += 1) < max
+            n, j, pr = cols[i]
             row[n] = pr.call(result, j)
           end
           yield row