sequel 5.39.0 → 5.63.0

data/doc/sql.rdoc

@@ -223,22 +223,22 @@ If the database supports window functions, Sequel can handle them by calling the
   DB[:albums].select{count.function.*.over}
   # SELECT count(*) OVER () FROM albums
 
-  DB[:albums].select{function(:col1).over(:partition=>col2, :order=>col3)}
+  DB[:albums].select{function(:col1).over(partition: col2, order: col3)}
   # SELECT function(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM albums
 
-  DB[:albums].select{function(c1, c2).over(:partition=>[c3, c4], :order=>[c5, c6.desc])}
+  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)}
+  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})}
+  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]})}
+  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})}
+  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
@@ -428,6 +428,18 @@ As you can see, these literalize with ANDs by default.  You can use the <tt>Sequ
 
   Sequel.or(column1: 1, column2: 2) # (("column1" = 1) OR ("column2" = 2))
 
+As you can see in the above examples, <tt>Sequel.|</tt> and <tt>Sequel.or</tt> work differently.
+<tt>Sequel.|</tt> is for combining an arbitrary number of expressions using OR. If you pass a single
+argument, <tt>Sequel.|</tt> will just convert it to a Sequel expression, similar to <tt>Sequel.expr</tt>.
+<tt>Sequel.or</tt> is for taking a single hash or array of two element arrays and combining the
+elements of that single argument using OR instead of AND:
+
+  Sequel.|(column1: 1, column2: 2) # (("column1" = 1) AND ("column2" = 2))
+  Sequel.or(column1: 1, column2: 2) # (("column1" = 1) OR ("column2" = 2))
+
+  Sequel.|({column1: 1}, {column2: 2}) # (("column1" = 1) OR ("column2" = 2))
+  Sequel.or({column1: 1}, {column2: 2}) # ArgumentError
+
 You've already seen the <tt>Sequel.negate</tt> method, which will use ANDs if multiple entries are used:
 
   Sequel.negate(column1: 1, column2: 2) # (("column1" != 1) AND ("column2" != 2))
@@ -516,7 +528,7 @@ Inverting the LIKE operator works like other inversions:
 
   ~Sequel.like(:name, 'A%') # ("name" NOT LIKE 'A%' ESCAPE '\')
 
-Sequel also supports SQL regular expressions on MySQL and PostgreSQL.  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
+Sequel also supports SQL regular expressions on MySQL and PostgreSQL (and SQLite when using the sqlite adapter with the :setup_regexp_function Database option).  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
 
   Sequel.like(:name, /^A/) # ("name" ~ '^A')
   ~Sequel.ilike(:name, /^A/) # ("name" !~* '^A')
@@ -539,12 +551,12 @@ You can also use the <tt>Sequel.asc</tt> and <tt>Sequel.desc</tt> methods:
 
 On some databases, you can specify null ordering:
 
-  Sequel.asc(:column, :nulls=>:first) # "column" ASC NULLS FIRST
-  Sequel.desc(Sequel[:table][:column], :nulls=>:last) # "table"."column" DESC NULLS LAST
+  Sequel.asc(:column, nulls: :first) # "column" ASC NULLS FIRST
+  Sequel.desc(Sequel[:table][:column], nulls: :last) # "table"."column" DESC NULLS LAST
 
 === All Columns (.*)
 
-To select all columns in a table, Sequel supports the * method on identifiers and qualified without an argument:
+To select all columns in a table, Sequel supports the * method on identifiers and qualified identifiers without an argument:
 
   Sequel[:table].*          # "table".*
   Sequel[:schema][:table].* # "schema"."table".*
@@ -617,16 +629,16 @@ Also note that while the SELECT clause is displayed when you look at a dataset,
 
   ds = DB[:albums]
   ds.all # SELECT * FROM albums
-  ds.insert(:name=>'RF') # INSERT INTO albums (name) VALUES ('RF')
-  ds.update(:name=>'RF') # UPDATE albums SET name = 'RF'
+  ds.insert(name: 'RF') # INSERT INTO albums (name) VALUES ('RF')
+  ds.update(name: 'RF') # UPDATE albums SET name = 'RF'
   ds.delete # DELETE FROM albums
 
 In general, the +insert+, +update+, and +delete+ methods use the appropriate clauses you defined on the dataset:
 
-  ds = DB[:albums].where(:id=>1)
+  ds = DB[:albums].where(id: 1)
   ds.all # SELECT * FROM albums WHERE (id = 1)
-  ds.insert(:name=>'RF') # INSERT INTO albums (name) VALUES ('RF')
-  ds.update(:name=>'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
+  ds.insert(name: 'RF') # INSERT INTO albums (name) VALUES ('RF')
+  ds.update(name: 'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
   ds.delete # DELETE FROM albums WHERE (id = 1)
 
 Note how +update+ and +delete+ used the +where+ argument, but +insert+ did not, because INSERT doesn't use a WHERE clause.

data/doc/testing.rdoc

@@ -15,7 +15,7 @@ These run each test in its own transaction, the recommended way to test.
   
   class Minitest::HooksSpec
     def around
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, auto_savepoint: true){super}
     end
   end
 
@@ -24,7 +24,7 @@ These run each test in its own transaction, the recommended way to test.
   
   class Minitest::Spec
     def run(*args, &block)
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, auto_savepoint: true){super}
     end
   end
 
@@ -34,7 +34,7 @@ These run each test in its own transaction, the recommended way to test.
   # Use this class as the base class for your tests
   class SequelTestCase < Minitest::Test
     def run(*args, &block)
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, auto_savepoint: true){super}
     end
   end
 
@@ -43,7 +43,7 @@ These run each test in its own transaction, the recommended way to test.
   
   RSpec.configure do |c|
     c.around(:each) do |example|
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){example.run}
+      DB.transaction(rollback: :always, auto_savepoint: true){example.run}
     end
   end
 
@@ -51,11 +51,11 @@ 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:
 
-  DB.transaction(:rollback=>:always)
+  DB.transaction(rollback: :always)
 
 Use Sequel.transaction with an array of databases:
 
-  Sequel.transaction([DB1, DB2, DB3], :rollback=>:always)
+  Sequel.transaction([DB1, DB2, DB3], rollback: :always)
 
 == Transactional testing with savepoints
 
@@ -71,11 +71,11 @@ Example:
   require 'minitest/hooks/default'
   class Minitest::HooksSpec
     def around
-      DB.transaction(:rollback=>:always, :savepoint=>true, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, savepoint: true, auto_savepoint: true){super}
     end
 
     def around_all
-      DB.transaction(:rollback=>:always){super}
+      DB.transaction(rollback: :always){super}
     end
   end
 
@@ -113,7 +113,7 @@ The order in which you delete/truncate the tables is important if you are using
 
 = Testing Sequel Itself
 
-Sequel has multiple separate test suites.  All test suites use minitest/spec, with the minitest-hooks and minitest-shared_description extensions.
+Sequel has multiple separate test suites.  All test suites use minitest/spec, with the minitest-hooks and minitest-global_expectations extensions.  To install the dependencies necessary to test Sequel, run <tt>gem install --development sequel</tt>.
 
 == rake
 
@@ -145,6 +145,8 @@ The <tt>spec_<i>adapter</i></tt> specs run against a real database connection wi
 
 These specs are broken down into two parts.  For each database, there are specific specs that only apply to that database, and these are called the adapter specs.  There are also shared specs that apply to all (or almost all) databases, these are called the integration specs. For database types that don't have specific adapter tests, you can use <tt>rake spec_integration</tt> to just run the shared integration tests.
 
+Each adapter needs a specific gem installed in order to run.  Please see the {connecting to a database guide}[rdoc-ref:doc/opening_databases.rdoc] for which gem you need to install for the adapter you are testing.
+
 == Environment variables
 
 Sequel uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying <tt>spec/spec_config.rb.example</tt> to <tt>spec/spec_config.rb</tt> and modifying it.  See that file for details.  It may be necessary to use +spec_config.rb+ as opposed to an environment variable if your database connection cannot be specified by a connection string.
@@ -157,21 +159,30 @@ The SEQUEL_INTEGRATION_URL environment variable specifies the Database connectio
 
 === Other
 
+SEQUEL_ASYNC_THREAD_POOL :: Use the async_thread_pool extension when running the specs
+SEQUEL_ASYNC_THREAD_POOL_PREEMPT :: Use the async_thread_pool extension when running the specs, with the :preempt_async_thread option
+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_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
+SEQUEL_CONCURRENT_EAGER_LOADING :: Use the async_thread_pool extension and concurrent_eager_loading plugin when running the specs
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
 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_INDEX_CACHING :: Use the index_caching 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_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_AUTO_PARAMETERIZE :: Use the pg_auto_parameterize extension when running the postgres specs
 SEQUEL_PG_TIMESTAMPTZ :: Use the pg_timestamptz extension when running the postgres specs
+SEQUEL_PRIMARY_KEY_LOOKUP_CHECK_VALUES :: Use the primary_key_lookup_check_values extension when running the adapter or integration specs
+SEQUEL_QUERY_PER_ASSOCIATION_DB_0_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
+SEQUEL_QUERY_PER_ASSOCIATION_DB_1_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
+SEQUEL_QUERY_PER_ASSOCIATION_DB_2_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
+SEQUEL_QUERY_PER_ASSOCIATION_DB_3_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
 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

@@ -127,28 +127,28 @@ 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>
+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)
+      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)
+        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>
+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)
+        DB.rollback_on_exit(savepoint: 2)
       end # ROLLBACK TO SAVEPOINT
     end # ROLLBACK TO SAVEPOINT
   end # COMMIT
@@ -156,7 +156,7 @@ If you want the current savepoint and potentially enclosing savepoints to be rol
   DB.transaction do # BEGIN
     DB.transaction(savepoint: true) do # SAVEPOINT
       DB.transaction(savepoint: true) do # SAVEPOINT
-        DB.rollback_on_exit(:savepoint=>3)
+        DB.rollback_on_exit(savepoint: 3)
       end # ROLLBACK TO SAVEPOINT
     end # ROLLBACK TO SAVEPOINT
   end # ROLLBACK

data/doc/virtual_rows.rdoc

@@ -23,7 +23,7 @@ With virtual rows, you can use the less verbose:
 Virtual row blocks behave differently depending on whether the block accepts
 an argument.  If the block accepts an argument, it is called with an instance
 of Sequel::SQL::VirtualRow.  If it does not accept an argument, it is
-evaluated in the context of an instance of Sequel::SQL::VirtualRow.
+evaluated in the <em> context of an instance </em> of Sequel::SQL::VirtualRow.
 
   ds = DB[:items]
   # Regular block
@@ -54,7 +54,7 @@ methods in the surrounding scope. For example:
   
   # Regular block
   ds.where{|o| o.c > a - b + @d}
-  # WHERE (c > 100)
+  # WHERE (c > 110)
   
   # Instance-evaled block
   ds.where{c > a - b + @d}

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

@@ -318,7 +318,7 @@ module Sequel
                   conn.OpenSchema(ado_schema.type, ado_schema.criteria) 
                 end
               }
-              yield(r) if block_given?
+              yield(r) if defined?(yield)
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)
             end

data/lib/sequel/adapters/ado.rb

@@ -161,7 +161,7 @@ module Sequel
           begin
             r = log_connection_yield(sql, conn){conn.Execute(sql)}
             begin
-              yield r if block_given?
+              yield r if defined?(yield)
             ensure
               begin
                 r.close
@@ -195,10 +195,25 @@ module Sequel
         end
 
         @conversion_procs = CONVERSION_PROCS.dup
+        @conversion_procs[AdDBTimeStamp] = method(:adb_timestamp_to_application_timestamp)
 
         super
       end
 
+      def adb_timestamp_to_application_timestamp(v)
+        # This hard codes a timestamp_precision of 6 when converting.
+        # That is the default timestamp_precision, but the ado/mssql adapter uses a timestamp_precision
+        # of 3.  However, timestamps returned by ado/mssql have nsec values that end up rounding to a
+        # the same value as if a timestamp_precision of 3 was hard coded (either xxx999yzz, where y is
+        # 5-9 or xxx000yzz where y is 0-4).
+        #
+        # ADO subadapters should override this they would like a different timestamp precision and the
+        # this code does not work for them (for example, if they provide full nsec precision).
+        #
+        # Note that fractional second handling for WIN32OLE objects is not correct on ruby <2.2
+        to_application_timestamp([v.year, v.month, v.day, v.hour, v.min, v.sec, (v.nsec/1000.0).round * 1000])
+      end
+
       def dataset_class_default
         Dataset
       end
@@ -233,23 +248,8 @@ module Sequel
           cols = []
           conversion_procs = db.conversion_procs
 
-          ts_cp = nil
           recordset.Fields.each do |field|
-            type = field.Type
-            cp = if type == AdDBTimeStamp
-              ts_cp ||= begin
-                nsec_div = 1000000000.0/(10**(timestamp_precision))
-                nsec_mul = 10**(timestamp_precision+3)
-                meth = db.method(:to_application_timestamp)
-                lambda do |v|
-                  # Fractional second handling is not correct on ruby <2.2
-                  meth.call([v.year, v.month, v.day, v.hour, v.min, v.sec, (v.nsec/nsec_div).round * nsec_mul])
-                end
-              end
-            else
-              conversion_procs[type]
-            end
-            cols << [output_identifier(field.Name), cp]
+            cols << [output_identifier(field.Name), conversion_procs[field.Type]]
           end
 
           self.columns = cols.map(&:first)

data/lib/sequel/adapters/amalgalite.rb

@@ -118,11 +118,9 @@ module Sequel
       # Yield an available connection.  Rescue
       # any Amalgalite::Errors and turn them into DatabaseErrors.
       def _execute(sql, opts)
-        begin
-          synchronize(opts[:server]){|conn| yield conn}
-        rescue ::Amalgalite::Error, ::Amalgalite::SQLite3::Error => e
-          raise_error(e)
-        end
+        synchronize(opts[:server]){|conn| yield conn}
+      rescue ::Amalgalite::Error, ::Amalgalite::SQLite3::Error => e
+        raise_error(e)
       end
       
       # The Amagalite adapter does not need the pool to convert exceptions.

data/lib/sequel/adapters/ibmdb.rb

@@ -246,7 +246,7 @@ module Sequel
           end
           begin
             stmt = log_connection_yield(log_sql, conn, args){conn.execute_prepared(ps_name, *args)}
-            if block_given?
+            if defined?(yield)
               yield(stmt)
             else  
               stmt.affected
@@ -268,7 +268,7 @@ module Sequel
       # is given or returning the number of affected rows if not, and ensuring the statement is freed.
       def _execute(conn, sql, opts)
         stmt = log_connection_yield(sql, conn){conn.execute(sql)}
-        if block_given?
+        if defined?(yield)
           yield(stmt)
         else  
           stmt.affected

data/lib/sequel/adapters/jdbc/derby.rb

@@ -2,6 +2,7 @@
 
 Sequel::JDBC.load_driver('org.apache.derby.jdbc.EmbeddedDriver', :Derby)
 require_relative 'transactions'
+require_relative '../utils/columns_limit_1'
 
 module Sequel
   module JDBC
@@ -182,6 +183,8 @@ module Sequel
       end
       
       class Dataset < JDBC::Dataset
+        include ::Sequel::Dataset::ColumnsLimit1
+
         # Derby doesn't support an expression between CASE and WHEN,
         # so remove conditions.
         def case_expression_sql_append(sql, ce)
@@ -232,6 +235,11 @@ module Sequel
           false
         end
 
+        # Derby 10.11+ supports MERGE.
+        def supports_merge?
+          db.svn_version >= 1616546
+        end
+
         # Derby does not support IN/NOT IN with multiple columns
         def supports_multiple_column_in?
           false

data/lib/sequel/adapters/jdbc/h2.rb

@@ -24,6 +24,7 @@ module Sequel
 
         def freeze
           h2_version
+          version2?
           super
         end
 
@@ -140,13 +141,36 @@ module Sequel
           DATABASE_ERROR_REGEXPS
         end
 
-        # Use IDENTITY() to get the last inserted id.
+        def execute_statement_insert(stmt, sql)
+          stmt.executeUpdate(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS)
+        end
+
+        def prepare_jdbc_statement(conn, sql, opts)
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS) : super
+        end
+
+        # Get the last inserted id using getGeneratedKeys, scope_identity, or identity.
         def last_insert_id(conn, opts=OPTS)
-          statement(conn) do |stmt|
-            sql = 'SELECT IDENTITY();'
-            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
-            rs.next
-            rs.getLong(1)
+          if stmt = opts[:stmt]
+            rs = stmt.getGeneratedKeys
+            begin
+              if rs.next
+                begin
+                  rs.getLong(1)
+                rescue
+                  rs.getObject(1) rescue nil
+                end
+              end
+            ensure
+              rs.close
+            end
+          elsif !version2?
+            statement(conn) do |stmt|
+              sql = 'SELECT IDENTITY()'
+              rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
+              rs.next
+              rs.getLong(1)
+            end
           end
         end
         
@@ -161,7 +185,12 @@ module Sequel
 
         # Use BIGINT IDENTITY for identity columns that use :Bignum type
         def type_literal_generic_bignum_symbol(column)
-          column[:identity] ? 'BIGINT IDENTITY' : super
+          column[:identity] ? 'BIGINT AUTO_INCREMENT' : super
+        end
+
+        def version2?
+          return @version2 if defined?(@version2)
+          @version2 = h2_version.to_i >= 2
         end
       end
       
@@ -200,6 +229,11 @@ module Sequel
           false
         end
         
+        # H2 supports MERGE
+        def supports_merge?
+          true
+        end
+
         # H2 doesn't support multiple columns in IN/NOT IN
         def supports_multiple_column_in?
           false
@@ -209,9 +243,21 @@ module Sequel
 
         # H2 expects hexadecimal strings for blob values
         def literal_blob_append(sql, v)
-          sql << "'" << v.unpack("H*").first << "'"
+          if db.send(:version2?)
+            super
+          else
+            sql << "'" << v.unpack("H*").first << "'"
+          end
+        end
+
+        def literal_false
+          'FALSE'
         end
         
+        def literal_true
+          'TRUE'
+        end
+
         # H2 handles fractional seconds in timestamps, but not in times
         def literal_sqltime(v)
           v.strftime("'%H:%M:%S'")
@@ -223,8 +269,12 @@ module Sequel
         end
 
         def select_only_offset_sql(sql)
-          sql << " LIMIT -1 OFFSET "
-          literal_append(sql, @opts[:offset])
+          if db.send(:version2?)
+            super
+          else
+            sql << " LIMIT -1 OFFSET "
+            literal_append(sql, @opts[:offset])
+          end
         end
 
         # H2 supports quoted function names.

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -179,6 +179,12 @@ module Sequel
           true
         end
 
+        # HSQLDB 2.3.4+ supports MERGE.  Older versions also support MERGE, but not all
+        # features that are in Sequel's tests.
+        def supports_merge?
+          db.db_version >= 20304
+        end
+
         private
 
         def empty_from_sql

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -35,9 +35,9 @@ module Sequel
           data = opts[:data]
           data = Array(data) if data.is_a?(String)
 
-          if block_given? && data
+          if defined?(yield) && data
             raise Error, "Cannot provide both a :data option and a block to copy_into"
-          elsif !block_given? && !data
+          elsif !defined?(yield) && !data
             raise Error, "Must provide either a :data option or a block to copy_into"
           end
 
@@ -45,7 +45,7 @@ module Sequel
             begin
               copy_manager = org.postgresql.copy.CopyManager.new(conn)
               copier = copy_manager.copy_in(copy_into_sql(table, opts))
-              if block_given?
+              if defined?(yield)
                 while buf = yield
                   java_bytes = buf.to_java_bytes
                   copier.writeToCopy(java_bytes, 0, java_bytes.length)
@@ -77,7 +77,7 @@ module Sequel
             copy_manager = org.postgresql.copy.CopyManager.new(conn)
             copier = copy_manager.copy_out(copy_table_sql(table, opts))
             begin
-              if block_given?
+              if defined?(yield)
                 while buf = copier.readFromCopy
                   yield(String.from_java_bytes(buf))
                 end

data/lib/sequel/adapters/jdbc.rb

@@ -32,15 +32,13 @@ module Sequel
 
     # Allow loading the necessary JDBC support via a gem.
     def self.load_gem(name)
-      begin
-        require "jdbc/#{name.to_s.downcase}"
-      rescue LoadError
-        # jdbc gem not used, hopefully the user has the .jar in their CLASSPATH
-      else
-        if defined?(::Jdbc) && ( ::Jdbc.const_defined?(name) rescue nil )
-          jdbc_module = ::Jdbc.const_get(name) # e.g. Jdbc::SQLite3
-          jdbc_module.load_driver if jdbc_module.respond_to?(:load_driver)
-        end
+      require "jdbc/#{name.to_s.downcase}"
+    rescue LoadError
+      # jdbc gem not used, hopefully the user has the .jar in their CLASSPATH
+    else
+      if defined?(::Jdbc) && ( ::Jdbc.const_defined?(name) rescue nil )
+        jdbc_module = ::Jdbc.const_get(name) # e.g. Jdbc::SQLite3
+        jdbc_module.load_driver if jdbc_module.respond_to?(:load_driver)
       end
     end
 
@@ -71,11 +69,11 @@ module Sequel
     class TypeConvertor
       CONVERTORS = convertors = {}
       %w'Boolean Float Double Int Long Short'.each do |meth|
-        x = convertors[meth.to_sym] = Object.new
+        x = 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|
-        x = convertors[meth.to_sym] = Object.new
+        x = x = convertors[meth.to_sym] = Object.new
         class_eval("def x.call(r, i) r.get#{meth}(i) end", __FILE__, __LINE__)
       end
       x = convertors[:RubyTime] = Object.new
@@ -190,13 +188,13 @@ module Sequel
         args = opts[:args] || []
         sql = "{call #{name}(#{args.map{'?'}.join(',')})}"
         synchronize(opts[:server]) do |conn|
-          cps = conn.prepareCall(sql)
+          begin
+            cps = conn.prepareCall(sql)
 
-          i = 0
-          args.each{|arg| set_ps_arg(cps, arg, i+=1)}
+            i = 0
+            args.each{|arg| set_ps_arg(cps, arg, i+=1)}
 
-          begin
-            if block_given?
+            if defined?(yield)
               yield log_connection_yield(sql, conn){cps.executeQuery}
             else
               log_connection_yield(sql, conn){cps.executeUpdate}
@@ -207,7 +205,7 @@ module Sequel
           rescue *DATABASE_ERROR_CLASSES => e
             raise_error(e)
           ensure
-            cps.close
+            cps.close if cps
           end
         end
       end
@@ -461,7 +459,7 @@ module Sequel
             msg << ")"
           end
           begin
-            if block_given?
+            if defined?(yield)
               yield log_connection_yield(msg, conn, args){cps.executeQuery}
             else
               case opts[:type]