sequel 4.41.0 → 4.42.0

data/lib/sequel/sql.rb

@@ -26,7 +26,7 @@ module Sequel
     # +Object+.  This allows the virtual row support to work with classes
     # without prefixing them with ::, such as:
     #
-    #   DB[:bonds].filter{maturity_date > Time.now}
+    #   DB[:bonds].where{maturity_date > Time.now}
     class BasicObject < ::BasicObject
       # Lookup missing constants in <tt>::Object</tt>
       def self.const_missing(name)
@@ -252,7 +252,8 @@ module Sequel
           raise(Error, "Invalid operator #{op}")
         end
         @op = op
-        @args = args
+        @args = args.freeze
+        freeze
       end
       
       to_s_method :complex_expression_sql, '@op, @args'
@@ -596,10 +597,10 @@ module Sequel
       # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
       # literalization, e.g.:
       #
-      #   DB[:items].filter(:abc => 'def').sql #=>
+      #   DB[:items].where(:abc => 'def').sql #=>
       #     "SELECT * FROM items WHERE (abc = 'def')"
       #
-      #   DB[:items].filter(:abc => Sequel.lit('def')).sql #=>
+      #   DB[:items].where(:abc => Sequel.lit('def')).sql #=>
       #     "SELECT * FROM items WHERE (abc = def)"
       #
       # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:
@@ -682,9 +683,9 @@ module Sequel
       # this array as a value in a filter, but may be necessary if you are using it as a
       # value with placeholder SQL:
       #
-      #   DB[:a].filter([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
-      #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
-      #   DB[:a].filter('(a, b) IN ?', Sequel.value_list([[1, 2], [3, 4]])) # SQL: (a, b) IN ((1, 2), (3, 4))
+      #   DB[:a].where([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
+      #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
+      #   DB[:a].where('(a, b) IN ?', Sequel.value_list([[1, 2], [3, 4]])) # SQL: (a, b) IN ((1, 2), (3, 4))
       def value_list(arg)
         raise Error, 'argument to Sequel.value_list must be an array' unless arg.is_a?(Array)
         SQL::ValueList.new(arg)
@@ -1035,6 +1036,7 @@ module Sequel
         @expression = expression
         @aliaz = aliaz
         @columns = columns
+        freeze
       end
 
       to_s_method :aliased_expression_sql
@@ -1174,7 +1176,11 @@ module Sequel
       # all conditions represent their own boolean expression.
       def initialize(conditions, default, expression=(no_expression=true; nil))
         raise(Sequel::Error, 'CaseExpression conditions must be a hash or array of all two pairs') unless Sequel.condition_specifier?(conditions)
-        @conditions, @default, @expression, @no_expression = conditions.to_a, default, expression, no_expression
+        @conditions = conditions.to_a.dup.freeze
+        @default = default
+        @expression = expression
+        @no_expression = no_expression
+        freeze
       end
 
       # Whether to use an expression for this CASE expression.
@@ -1208,6 +1214,7 @@ module Sequel
       def initialize(expr, type)
         @expr = expr
         @type = type
+        freeze
       end
 
       to_s_method :cast_sql, '@expr, @type'
@@ -1221,6 +1228,7 @@ module Sequel
       # Create an object with the given table
       def initialize(table)
         @table = table
+        freeze
       end
 
       to_s_method :column_all_sql
@@ -1257,6 +1265,7 @@ module Sequel
       # Create an constant with the given value
       def initialize(constant)
         @constant = constant
+        freeze
       end
       
       to_s_method :constant_sql, '@constant'
@@ -1303,6 +1312,7 @@ module Sequel
       # Set the callable object
       def initialize(callable)
         @callable = callable
+        freeze
       end
 
       # Call the underlying callable and return the result.  If the
@@ -1337,15 +1347,11 @@ module Sequel
 
       # Set the name and args for the function
       def initialize(name, *args)
-        @name = name
-        @args = args
-        @opts = OPTS
+        _initialize(name, args, OPTS)
       end
 
       def self.new!(name, args, opts)
-        f = new(name, *args)
-        f.instance_variable_set(:@opts, opts)
-        f
+        allocate.send(:_initialize, name, args, opts)
       end
 
       # If no arguments are given, return a new function with the wildcard prepended to the arguments.
@@ -1372,7 +1378,12 @@ module Sequel
       #
       #   Sequel.function(:foo, :col).filter(:a=>1) # foo(col) FILTER (WHERE a = 1)
       def filter(*args, &block)
-        args = args.first if args.length == 1
+        if args.length == 1
+          args = args.first
+        else
+          args.freeze
+        end
+
         with_opts(:filter=>args, :filter_block=>block)
       end
 
@@ -1388,7 +1399,7 @@ module Sequel
       #
       #   Sequel.function(:foo, :a).order(:a, Sequel.desc(:b)) # foo(a ORDER BY a, b DESC)
       def order(*args)
-        with_opts(:order=>args)
+        with_opts(:order=>args.freeze)
       end
 
       # Return a new function with an OVER clause (making it a window function).
@@ -1430,13 +1441,21 @@ module Sequel
       #   Sequel.function(:rank, :a).within_group(:b, :c)
       #   # rank(a) WITHIN GROUP (ORDER BY b, c)
       def within_group(*expressions)
-        with_opts(:within_group=>expressions)
+        with_opts(:within_group=>expressions.freeze)
       end
 
       to_s_method :function_sql
 
       private
 
+      # Set args and opts
+      def _initialize(name, args, opts)
+        @name = name
+        @args = args.freeze
+        @opts = opts.freeze
+        freeze
+      end
+
       # Return a new function call with the given opts merged into the current opts.
       def with_opts(opts)
         self.class.new!(name, args, Hash[@opts].merge!(opts))
@@ -1468,6 +1487,7 @@ module Sequel
       # Set the value to the given argument
       def initialize(value)
         @value = value
+        freeze
       end
 
       # Create a Function using this identifier as the functions name, with
@@ -1492,6 +1512,7 @@ module Sequel
       def initialize(join_type, table_expr)
         @join_type = join_type
         @table_expr = table_expr
+        freeze
       end
 
       # The table/set related to the JOIN, without any alias.
@@ -1545,8 +1566,8 @@ module Sequel
 
       # Create an object with the given USING conditions and call super
       # with the remaining args.
-      def initialize(using, *args)
-        @using = using
+      def initialize(cols, *args)
+        @using = cols 
         super(*args)
       end
 
@@ -1617,7 +1638,10 @@ module Sequel
       #
       # :nulls :: Can be :first/:last for NULLS FIRST/LAST.
       def initialize(expression, descending = true, opts=OPTS)
-        @expression, @descending, @nulls = expression, descending, opts[:nulls]
+        @expression = expression
+        @descending = descending
+        @nulls = opts[:nulls]
+        freeze
       end
 
       # Return a copy that is ordered ASC
@@ -1652,6 +1676,7 @@ module Sequel
       def initialize(table, column)
         @table = convert_identifier(table)
         @column = convert_identifier(column)
+        freeze
       end
       
       # Create a Function using this identifier as the functions name, with
@@ -1746,7 +1771,9 @@ module Sequel
 
       # Set the array column and subscripts to the given arguments
       def initialize(f, sub)
-        @f, @sub = f, sub
+        @f = f
+        @sub = sub
+        freeze
       end
 
       # Create a new +Subscript+ appending the given subscript(s)
@@ -1781,7 +1808,7 @@ module Sequel
     # the methods defined by Sequel, if you are running on ruby 1.9, or if you are not using the
     # core extensions.
     #
-    # An instance of this class is yielded to the block supplied to <tt>Dataset#filter</tt>, <tt>Dataset#order</tt>, and <tt>Dataset#select</tt>
+    # An instance of this class is yielded to the block supplied to <tt>Dataset#where</tt>, <tt>Dataset#order</tt>, and <tt>Dataset#select</tt>
     # (and the other methods that accept a block and pass it to one of those methods).
     # If the block doesn't take an argument, the block is instance_execed in the context of
     # an instance of this class.
@@ -1814,16 +1841,16 @@ module Sequel
     #   ds = DB[:t]
     #
     #   # Argument yielded to block
-    #   ds.filter{|r| r.name < 2} # SELECT * FROM t WHERE (name < 2)
+    #   ds.where{|r| r.name < 2} # SELECT * FROM t WHERE (name < 2)
     #
     #   # Block without argument (instance_eval)
-    #   ds.filter{name < 2} # SELECT * FROM t WHERE (name < 2)
+    #   ds.where{name < 2} # SELECT * FROM t WHERE (name < 2)
     #
     #   # Qualified identifiers
-    #   ds.filter{table__column + 1 < 2} # SELECT * FROM t WHERE ((table.column + 1) < 2)
+    #   ds.where{table__column + 1 < 2} # SELECT * FROM t WHERE ((table.column + 1) < 2)
     #
     #   # Functions
-    #   ds.filter{is_active(1, 'arg2')} # SELECT * FROM t WHERE is_active(1, 'arg2')
+    #   ds.where{is_active(1, 'arg2')} # SELECT * FROM t WHERE is_active(1, 'arg2')
     #   ds.select{version{}} # SELECT version() FROM t
     #   ds.select{count(:*){}} # SELECT count(*) FROM t
     #   ds.select{count(:distinct, col1){}} # SELECT count(DISTINCT col1) FROM t
@@ -1840,19 +1867,19 @@ module Sequel
     #   ds.select{|o| o./(4, :a).as(:b)} # SELECT (4 / a) AS b FROM t
     #
     #   # Boolean Operators
-    #   ds.filter{|o| o.&({:a=>1}, :b)}    # SELECT * FROM t WHERE ((a = 1) AND b)
-    #   ds.filter{|o| o.|({:a=>1}, :b)}    # SELECT * FROM t WHERE ((a = 1) OR b)
-    #   ds.filter{|o| o.~({:a=>1})}        # SELECT * FROM t WHERE (a != 1)
-    #   ds.filter{|o| o.~({:a=>1, :b=>2})} # SELECT * FROM t WHERE ((a != 1) OR (b != 2))
+    #   ds.where{|o| o.&({:a=>1}, :b)}    # SELECT * FROM t WHERE ((a = 1) AND b)
+    #   ds.where{|o| o.|({:a=>1}, :b)}    # SELECT * FROM t WHERE ((a = 1) OR b)
+    #   ds.where{|o| o.~({:a=>1})}        # SELECT * FROM t WHERE (a != 1)
+    #   ds.where{|o| o.~({:a=>1, :b=>2})} # SELECT * FROM t WHERE ((a != 1) OR (b != 2))
     #
     #   # Inequality Operators
-    #   ds.filter{|o| o.>(1, :a)}  # SELECT * FROM t WHERE (1 > a)
-    #   ds.filter{|o| o.<(2, :a)}  # SELECT * FROM t WHERE (2 < a)
-    #   ds.filter{|o| o.>=(3, :a)} # SELECT * FROM t WHERE (3 >= a)
-    #   ds.filter{|o| o.<=(4, :a)} # SELECT * FROM t WHERE (4 <= a)
+    #   ds.where{|o| o.>(1, :a)}  # SELECT * FROM t WHERE (1 > a)
+    #   ds.where{|o| o.<(2, :a)}  # SELECT * FROM t WHERE (2 < a)
+    #   ds.where{|o| o.>=(3, :a)} # SELECT * FROM t WHERE (3 >= a)
+    #   ds.where{|o| o.<=(4, :a)} # SELECT * FROM t WHERE (4 <= a)
     #
     #   # Literal Strings
-    #   ds.filter{{a=>`some SQL`}} # SELECT * FROM t WHERE (a = some SQL)
+    #   ds.where{{a=>`some SQL`}} # SELECT * FROM t WHERE (a = some SQL)
     #
     # For a more detailed explanation, see the {Virtual Rows guide}[rdoc-ref:doc/virtual_rows.rdoc].
     class VirtualRow < BasicObject
@@ -1869,6 +1896,10 @@ module Sequel
         END
       end
 
+      def initialize
+        freeze
+      end
+
       # Return a literal string created with the given string.
       def `(s)
         Sequel::LiteralString.new(s)
@@ -1924,7 +1955,8 @@ module Sequel
 
       # Set the options to the options given
       def initialize(opts=OPTS)
-        @opts = opts
+        @opts = opts.frozen? ? opts : Hash[opts].freeze
+        freeze
       end
 
       to_s_method :window_sql, '@opts'
@@ -1939,6 +1971,7 @@ module Sequel
       # Set the value wrapped by the object.
       def initialize(value)
         @value = value
+        freeze
       end
 
       to_s_method :literal, '@value'

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 41
+  MINOR = 42
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/db2_spec.rb

@@ -118,6 +118,11 @@ describe "Sequel::IBMDB.convert_smallint_to_bool" do
     @ds.delete
     @ds << {:b=>true, :i=>1}
     @ds.all.must_equal [{:b=>true, :i=>1}]
+
+    @ds = @ds.with_convert_smallint_to_bool(false)
+    @ds.delete
+    @ds << {:b=>true, :i=>10}
+    @ds.all.must_equal [{:b=>1, :i=>10}]
   end
 
   it "should return all smallints as integers when unset" do
@@ -135,6 +140,11 @@ describe "Sequel::IBMDB.convert_smallint_to_bool" do
     @ds.delete
     @ds << {:b=>0, :i=>0}
     @ds.all.must_equal [{:b=>0, :i=>0}]
+
+    @ds = @ds.with_convert_smallint_to_bool(true)
+    @ds.delete
+    @ds << {:b=>true, :i=>10}
+    @ds.all.must_equal [{:b=>true, :i=>10}]
   end
 end if DB.adapter_scheme == :ibmdb
 

data/spec/adapters/firebird_spec.rb

@@ -381,7 +381,7 @@ describe "Postgres::Dataset#insert" do
   it "should return nil if the table has no primary key" do
     ds = DB[:test]
     ds.delete
-    ds.insert(:name=>'a').must_equal nil
+    ds.insert(:name=>'a').must_be_nil
   end
 end
 

data/spec/adapters/mssql_spec.rb

@@ -352,14 +352,14 @@ describe "MSSSQL::Dataset#insert" do
   end
 
   it "should have insert_select return nil if disable_insert_output is used" do
-    @ds.disable_insert_output.insert_select(:value=>10).must_equal nil
+    @ds.disable_insert_output.insert_select(:value=>10).must_be_nil
   end
   
   it "should have insert_select return nil if the server version is not 2005+" do
-    @ds = @ds.with_extend(Module.new do
+    @ds = @ds.with_extend do
       def server_version() 8000760 end
-    end)
-    @ds.insert_select(:value=>10).must_equal nil
+    end
+    @ds.insert_select(:value=>10).must_be_nil
   end
 
   it "should have insert_select insert the record and return the inserted record" do
@@ -427,7 +427,6 @@ end
 
 describe "MSSQL::Database#rename_table" do
   it "should work on non-schema bound tables which need escaping" do
-    DB.quote_identifiers = true
     DB.create_table! :'foo bar' do
       text :name
     end

data/spec/adapters/mysql_spec.rb

@@ -150,10 +150,10 @@ if [:mysql, :mysql2].include?(DB.adapter_scheme)
 
     it "should allow disabling the conversion on a per-dataset basis" do
       @db.convert_tinyint_to_bool = true
-      ds = @ds.with_extend(Module.new do
+      ds = @ds.with_extend do
         def cast_tinyint_integer?(f) true end #mysql
         def convert_tinyint_to_bool?() false end #mysql2
-      end)
+      end
       ds.delete
       ds << {:b=>true, :i=>10}
       ds.all.must_equal [{:b=>1, :i=>10}]
@@ -597,7 +597,7 @@ describe "A MySQL database" do
     @db[:items].first.must_equal(:name => 'tutu', :value => 1234)
 
     @db << 'DELETE FROM items'
-    @db[:items].first.must_equal nil
+    @db[:items].first.must_be_nil
   end
 end  
 
@@ -1208,13 +1208,13 @@ if DB.adapter_scheme == :mysql
 
     it "should not use a nil value bad date/time is used and convert_invalid_date_time is nil or :nil" do
       DB.convert_invalid_date_time = nil
-      DB["SELECT CAST('0000-00-00' AS date)"].single_value.must_equal nil
-      DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.must_equal nil
-      DB["SELECT CAST('25:00:00' AS time)"].single_value.must_equal nil
+      DB["SELECT CAST('0000-00-00' AS date)"].single_value.must_be_nil
+      DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.must_be_nil
+      DB["SELECT CAST('25:00:00' AS time)"].single_value.must_be_nil
       DB.convert_invalid_date_time = :nil
-      DB["SELECT CAST('0000-00-00' AS date)"].single_value.must_equal nil
-      DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.must_equal nil
-      DB["SELECT CAST('25:00:00' AS time)"].single_value.must_equal nil
+      DB["SELECT CAST('0000-00-00' AS date)"].single_value.must_be_nil
+      DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.must_be_nil
+      DB["SELECT CAST('25:00:00' AS time)"].single_value.must_be_nil
     end
 
     it "should not use a nil value bad date/time is used and convert_invalid_date_time is :string" do

data/spec/adapters/postgres_spec.rb

@@ -199,12 +199,12 @@ describe "PostgreSQL", 'INSERT ON CONFLICT' do
     @ds.insert(10, 11, 3, true)
     proc{@ds.insert(1, 3, 4)}.must_raise Sequel::UniqueConstraintViolation
     proc{@ds.insert(11, 12, 3, true)}.must_raise Sequel::UniqueConstraintViolation
-    @ds.insert_ignore.insert(1, 3, 4).must_equal nil
-    @ds.insert_conflict.insert(1, 3, 4).must_equal nil
-    @ds.insert_conflict.insert(11, 12, 3, true).must_equal nil
-    @ds.insert_conflict(:target=>:a).insert(1, 3, 4).must_equal nil
-    @ds.insert_conflict(:target=>:c, :conflict_where=>:c_is_unique).insert(11, 12, 3, true).must_equal nil
-    @ds.insert_conflict(:constraint=>:ic_test_a_uidx).insert(1, 3, 4).must_equal nil
+    @ds.insert_ignore.insert(1, 3, 4).must_be_nil
+    @ds.insert_conflict.insert(1, 3, 4).must_be_nil
+    @ds.insert_conflict.insert(11, 12, 3, true).must_be_nil
+    @ds.insert_conflict(:target=>:a).insert(1, 3, 4).must_be_nil
+    @ds.insert_conflict(:target=>:c, :conflict_where=>:c_is_unique).insert(11, 12, 3, true).must_be_nil
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx).insert(1, 3, 4).must_be_nil
     @ds.all.must_equal [{:a=>1, :b=>2, :c=>3, :c_is_unique=>false}, {:a=>10, :b=>11, :c=>3, :c_is_unique=>true}]
   end
 
@@ -221,15 +221,15 @@ describe "PostgreSQL", 'INSERT ON CONFLICT' do
 
   it "Dataset#insert_conflict should handle upserts" do
     @ds.insert(1, 2, 3)
-    @ds.insert_conflict(:target=>:a, :update=>{:b=>3}).insert(1, 3, 4).must_equal nil
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>3}).insert(1, 3, 4).must_be_nil
     @ds.all.must_equal [{:a=>1, :b=>3, :c=>3, :c_is_unique=>false}]
-    @ds.insert_conflict(:target=>[:b, :c], :update=>{:c=>5}).insert(5, 3, 3).must_equal nil
+    @ds.insert_conflict(:target=>[:b, :c], :update=>{:c=>5}).insert(5, 3, 3).must_be_nil
     @ds.all.must_equal [{:a=>1, :b=>3, :c=>5, :c_is_unique=>false}]
-    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>4}).insert(1, 3).must_equal nil
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>4}).insert(1, 3).must_be_nil
     @ds.all.must_equal [{:a=>1, :b=>4, :c=>5, :c_is_unique=>false}]
-    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>5}, :update_where=>{Sequel[:ic_test][:b]=>4}).insert(1, 3, 4).must_equal nil
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>5}, :update_where=>{Sequel[:ic_test][:b]=>4}).insert(1, 3, 4).must_be_nil
     @ds.all.must_equal [{:a=>1, :b=>5, :c=>5, :c_is_unique=>false}]
-    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>6}, :update_where=>{Sequel[:ic_test][:b]=>4}).insert(1, 3, 4).must_equal nil
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>6}, :update_where=>{Sequel[:ic_test][:b]=>4}).insert(1, 3, 4).must_be_nil
     @ds.all.must_equal [{:a=>1, :b=>5, :c=>5, :c_is_unique=>false}]
   end
 
@@ -284,12 +284,12 @@ describe "A PostgreSQL database" do
   it "should support disable_insert_returning" do
     ds = @db[Sequel[:public][:testfk]].disable_insert_returning
     ds.delete
-    ds.insert.must_equal nil
+    ds.insert.must_be_nil
     id = ds.max(:id)
     ds.select_order_map([:id, :i]).must_equal [[id, nil]]
-    ds.insert(:i=>id).must_equal nil
+    ds.insert(:i=>id).must_be_nil
     ds.select_order_map([:id, :i]).must_equal [[id, nil], [id+1, id]]
-    ds.insert_select(:i=>ds.max(:id)).must_equal nil
+    ds.insert_select(:i=>ds.max(:id)).must_be_nil
     ds.select_order_map([:id, :i]).must_equal [[id, nil], [id+1, id]]
     c = Class.new(Sequel::Model(ds))
     c.class_eval do
@@ -510,8 +510,8 @@ describe "A PostgreSQL dataset" do
     info[:schema].must_equal 'public'
     info[:table].must_equal 'atest'
     info[:constraint].must_equal 'f'
-    info[:column].must_equal nil
-    info[:type].must_equal nil
+    info[:column].must_be_nil
+    info[:type].must_be_nil
 
     begin
       @db[:atest].insert(0, nil)
@@ -521,9 +521,9 @@ describe "A PostgreSQL dataset" do
     info = @db.error_info(e.wrapped_exception)
     info[:schema].must_equal 'public'
     info[:table].must_equal 'atest'
-    info[:constraint].must_equal nil
+    info[:constraint].must_be_nil
     info[:column].must_equal 't2'
-    info[:type].must_equal nil
+    info[:type].must_be_nil
   end if DB.server_version >= 90300 && DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && Object.const_defined?(:PG) && ::PG.const_defined?(:Constants) && ::PG::Constants.const_defined?(:PG_DIAG_SCHEMA_NAME)
 
   it "should support Database#do for executing anonymous code blocks" do
@@ -667,8 +667,8 @@ describe "A PostgreSQL dataset" do
   end
 
   it "#lock should return nil" do
-    @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}.must_equal nil
-    @db.transaction{@d.lock('EXCLUSIVE').must_equal nil; @d.insert(:name=>'a')}
+    @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}.must_be_nil
+    @db.transaction{@d.lock('EXCLUSIVE').must_be_nil; @d.insert(:name=>'a')}
   end
 
   it "should raise an error if attempting to update a joined dataset with a single FROM table" do
@@ -817,22 +817,21 @@ describe "A PostgreSQL dataset with a timestamp field" do
     it "should handle infinite timestamps if convert_infinite_timestamps is set" do
       @d << {:time=>Sequel.cast('infinity', DateTime)}
       @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:time).must_equal nil
+      @db[:test3].get(:time).must_be_nil
       @db.convert_infinite_timestamps = :string
       @db[:test3].get(:time).must_equal 'infinity'
       @db.convert_infinite_timestamps = :float
       @db[:test3].get(:time).must_equal 1.0/0.0
       @db.convert_infinite_timestamps = 'nil'
-      @db[:test3].get(:time).must_equal nil
+      @db[:test3].get(:time).must_be_nil
       @db.convert_infinite_timestamps = 'string'
       @db[:test3].get(:time).must_equal 'infinity'
       @db.convert_infinite_timestamps = 'float'
       @db[:test3].get(:time).must_equal 1.0/0.0
       @db.convert_infinite_timestamps = 't'
       @db[:test3].get(:time).must_equal 1.0/0.0
-      if ((Time.parse('infinity'); nil) rescue true)
-        # Skip for loose time parsing (e.g. old rbx)
-        @db.convert_infinite_timestamps = 'f'
+      @db.convert_infinite_timestamps = 'f'
+      if RUBY_VERSION >= '1.9'
         proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
         @db.convert_infinite_timestamps = nil
         proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
@@ -842,7 +841,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
 
       @d.update(:time=>Sequel.cast('-infinity', DateTime))
       @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:time).must_equal nil
+      @db[:test3].get(:time).must_be_nil
       @db.convert_infinite_timestamps = :string
       @db[:test3].get(:time).must_equal '-infinity'
       @db.convert_infinite_timestamps = :float
@@ -861,7 +860,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
     it "should handle infinite dates if convert_infinite_timestamps is set" do
       @d << {:date=>Sequel.cast('infinity', Date)}
       @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:date).must_equal nil
+      @db[:test3].get(:date).must_be_nil
       @db.convert_infinite_timestamps = :string
       @db[:test3].get(:date).must_equal 'infinity'
       @db.convert_infinite_timestamps = :float
@@ -869,7 +868,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
 
       @d.update(:date=>Sequel.cast('-infinity', :timestamp))
       @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:date).must_equal nil
+      @db[:test3].get(:date).must_be_nil
       @db.convert_infinite_timestamps = :string
       @db[:test3].get(:date).must_equal '-infinity'
       @db.convert_infinite_timestamps = :float
@@ -975,7 +974,7 @@ describe "A PostgreSQL database" do
 
   it "should not raise an error if attempting to resetting the primary key sequence for a table without a primary key" do
     @db.create_table(:posts){Integer :a}
-    @db.reset_primary_key_sequence(:posts).must_equal nil
+    @db.reset_primary_key_sequence(:posts).must_be_nil
   end
 
   it "should support opclass specification" do
@@ -1138,8 +1137,8 @@ describe "Postgres::Dataset#insert" do
   end
 
   it "should work with static SQL" do
-    @ds.with_sql('INSERT INTO test5 (value) VALUES (10)').insert.must_equal nil
-    @db['INSERT INTO test5 (value) VALUES (20)'].insert.must_equal nil
+    @ds.with_sql('INSERT INTO test5 (value) VALUES (10)').insert.must_be_nil
+    @db['INSERT INTO test5 (value) VALUES (20)'].insert.must_be_nil
     @ds.all.must_equal [{:xid=>1, :value=>10}, {:xid=>2, :value=>20}]
   end
 
@@ -1185,7 +1184,7 @@ describe "Postgres::Dataset#insert" do
   it "should return nil if the table has no primary key" do
     @db.create_table!(:test5){String :name; Integer :value}
     @ds.delete
-    @ds.insert(:name=>'a').must_equal nil
+    @ds.insert(:name=>'a').must_be_nil
   end
 end
 
@@ -1202,14 +1201,14 @@ describe "Postgres::Database schema qualified tables" do
 
   it "should be able to create, drop, select and insert into tables in a given schema" do
     @db.create_table(Sequel[:schema_test][:schema_test]){primary_key :i}
-    @db[Sequel[:schema_test][:schema_test]].first.must_equal nil
+    @db[Sequel[:schema_test][:schema_test]].first.must_be_nil
     @db[Sequel[:schema_test][:schema_test]].insert(:i=>1).must_equal 1
     @db[Sequel[:schema_test][:schema_test]].first.must_equal(:i=>1)
     @db.from(Sequel.lit('schema_test.schema_test')).first.must_equal(:i=>1)
     @db.drop_table(Sequel[:schema_test][:schema_test])
     @db.create_table(Sequel.qualify(:schema_test, :schema_test)){integer :i}
-    @db[Sequel[:schema_test][:schema_test]].first.must_equal nil
-    @db.from(Sequel.lit('schema_test.schema_test')).first.must_equal nil
+    @db[Sequel[:schema_test][:schema_test]].first.must_be_nil
+    @db.from(Sequel.lit('schema_test.schema_test')).first.must_be_nil
     @db.drop_table(Sequel.qualify(:schema_test, :schema_test))
   end
 
@@ -1727,11 +1726,11 @@ if DB.adapter_scheme == :postgres
     end
 
     it "should handle returning inside block" do
-      ds = @ds.with_extend(Module.new do
+      ds = @ds.with_extend do
         def check_return
           use_cursor.each{|r| return}
         end
-      end)
+      end
       ds.check_return
       ds.all.must_equal ds.use_cursor.all
     end
@@ -1994,30 +1993,30 @@ if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && DB.server_versio
           called2 = true
           break
         end
-      end.must_equal nil
+      end.must_be_nil
       called.must_equal true
       called2.must_equal true
       i.must_equal 1
     end
 
     it "should accept a :timeout option in listen" do
-      @db.listen('foo2', :timeout=>0.001).must_equal nil
+      @db.listen('foo2', :timeout=>0.001).must_be_nil
       called = false
-      @db.listen('foo2', :timeout=>0.001){|ev, pid, payload| called = true}.must_equal nil
+      @db.listen('foo2', :timeout=>0.001){|ev, pid, payload| called = true}.must_be_nil
       called.must_equal false
       i = 0
-      @db.listen('foo2', :timeout=>0.001, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.must_equal nil
+      @db.listen('foo2', :timeout=>0.001, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.must_be_nil
       i.must_equal 4
 
       called = false
       i = 0
-      @db.listen('foo2', :timeout=>proc{i+=1; 0.001}){|ev, pid, payload| called = true}.must_equal nil
+      @db.listen('foo2', :timeout=>proc{i+=1; 0.001}){|ev, pid, payload| called = true}.must_be_nil
       called.must_equal false
       i.must_equal 1
 
 	  i = 0
       t = 0
-      @db.listen('foo2', :timeout=>proc{t+=1; 0.001}, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.must_equal nil
+      @db.listen('foo2', :timeout=>proc{t+=1; 0.001}, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.must_be_nil
       called.must_equal false
       t.must_equal 4
 
@@ -2366,7 +2365,7 @@ describe 'PostgreSQL array handling' do
     @ds.call(:insert, {:i=>[1,2]}, {:i=>:$i})
     @ds.get(:i).must_equal [1, 2]
     @ds.filter(:i=>:$i).call(:first, :i=>[1,2]).must_equal(:i=>[1,2])
-    @ds.filter(:i=>:$i).call(:first, :i=>[1,3]).must_equal nil
+    @ds.filter(:i=>:$i).call(:first, :i=>[1,3]).must_be_nil
 
     # NULL values
     @ds.delete
@@ -2380,7 +2379,7 @@ describe 'PostgreSQL array handling' do
     @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a))
     @ds.get(:i).must_equal a
     @ds.filter(:i=>:$i).call(:first, :i=>a).must_equal(:i=>a)
-    @ds.filter(:i=>:$i).call(:first, :i=>['', nil, nil, 'a']).must_equal nil
+    @ds.filter(:i=>:$i).call(:first, :i=>['', nil, nil, 'a']).must_be_nil
 
     @db.create_table!(:items) do
       column :i, 'date[]'
@@ -2389,7 +2388,7 @@ describe 'PostgreSQL array handling' do
     @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a, 'date'))
     @ds.get(:i).must_equal a
     @ds.filter(:i=>:$i).call(:first, :i=>a).must_equal(:i=>a)
-    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([Date.today-1], 'date')).must_equal nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([Date.today-1], 'date')).must_be_nil
 
     @db.create_table!(:items) do
       column :i, 'timestamp[]'
@@ -2398,7 +2397,7 @@ describe 'PostgreSQL array handling' do
     @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a, 'timestamp'))
     @ds.get(:i).must_equal a
     @ds.filter(:i=>:$i).call(:first, :i=>a).must_equal(:i=>a)
-    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([a.first-1], 'timestamp')).must_equal nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([a.first-1], 'timestamp')).must_be_nil
 
     @db.create_table!(:items) do
       column :i, 'boolean[]'
@@ -2407,7 +2406,7 @@ describe 'PostgreSQL array handling' do
     @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a, 'boolean'))
     @ds.get(:i).must_equal a
     @ds.filter(:i=>:$i).call(:first, :i=>a).must_equal(:i=>a)
-    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([false, true], 'boolean')).must_equal nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([false, true], 'boolean')).must_be_nil
 
     @db.create_table!(:items) do
       column :i, 'bytea[]'
@@ -2416,7 +2415,7 @@ describe 'PostgreSQL array handling' do
     @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a, 'bytea'))
     @ds.get(:i).must_equal a
     @ds.filter(:i=>:$i).call(:first, :i=>a).must_equal(:i=>a)
-    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([Sequel.blob("b\0")], 'bytea')).must_equal nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([Sequel.blob("b\0")], 'bytea')).must_be_nil
   end if (DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || DB.adapter_scheme == :jdbc
 
   it 'with models' do
@@ -2594,7 +2593,7 @@ describe 'PostgreSQL hstore handling' do
     @ds.call(:insert, {:i=>Sequel.hstore(@h)}, {:i=>:$i})
     @ds.get(:i).must_equal @h
     @ds.filter(:i=>:$i).call(:first, :i=>Sequel.hstore(@h)).must_equal(:i=>@h)
-    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.hstore({})).must_equal nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.hstore({})).must_be_nil
 
     @ds.delete
     @ds.call(:insert, {:i=>Sequel.hstore('a'=>nil)}, {:i=>:$i})
@@ -2604,7 +2603,7 @@ describe 'PostgreSQL hstore handling' do
     @ds.call(:insert, {:i=>@h}, {:i=>:$i})
     @ds.get(:i).must_equal @h
     @ds.filter(:i=>:$i).call(:first, :i=>@h).must_equal(:i=>@h)
-    @ds.filter(:i=>:$i).call(:first, :i=>{}).must_equal nil
+    @ds.filter(:i=>:$i).call(:first, :i=>{}).must_be_nil
   end if (DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || DB.adapter_scheme == :jdbc
 
   it 'with models and associations' do
@@ -2712,7 +2711,7 @@ describe 'PostgreSQL hstore handling' do
     h3 = Sequel.hstore(:h3)
     
     @ds.get(h1['a']).must_equal 'b'
-    @ds.get(h1['d']).must_equal nil
+    @ds.get(h1['d']).must_be_nil
 
     @ds.get(h2.concat(h3).keys.length).must_equal 2
     @ds.get(h1.concat(h3).keys.length).must_equal 3
@@ -2735,9 +2734,9 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(h1.defined('c')).must_equal false
     @ds.get(h1.defined('d')).must_equal false
 
-    @ds.get(h1.delete('a')['c']).must_equal nil
-    @ds.get(h1.delete(%w'a d')['c']).must_equal nil
-    @ds.get(h1.delete(h2)['c']).must_equal nil
+    @ds.get(h1.delete('a')['c']).must_be_nil
+    @ds.get(h1.delete(%w'a d')['c']).must_be_nil
+    @ds.get(h1.delete(h2)['c']).must_be_nil
 
     @ds.from(Sequel.hstore('a'=>'b', 'c'=>nil).op.each).order(:key).all.must_equal [{:key=>'a', :value=>'b'}, {:key=>'c', :value=>nil}]
 
@@ -2766,7 +2765,7 @@ describe 'PostgreSQL hstore handling' do
 
     @ds.get(h1.slice(%w'a c').keys.length).must_equal 2
     @ds.get(h1.slice(%w'd c').keys.length).must_equal 1
-    @ds.get(h1.slice(%w'd e').keys.length).must_equal nil
+    @ds.get(h1.slice(%w'd e').keys.length).must_be_nil
 
     @ds.from(Sequel.hstore('t'=>'s', 'a'=>'b').op.svals.as(:s)).select_order_map(:s).must_equal %w'b s'
 
@@ -3056,7 +3055,7 @@ describe 'PostgreSQL inet/cidr types' do
     @ds.get(:i).must_equal @ipv4
     @ds.get(:c).must_equal @ipv4nm
     @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv4, :c=>@ipv4nm).must_equal(:i=>@ipv4, :c=>@ipv4nm)
-    @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv6, :c=>@ipv6nm).must_equal nil
+    @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv6, :c=>@ipv6nm).must_be_nil
     @ds.filter(:i=>:$i, :c=>:$c).call(:delete, :i=>@ipv4, :c=>@ipv4nm).must_equal 1
 
     unless ipv6_broken
@@ -3064,14 +3063,14 @@ describe 'PostgreSQL inet/cidr types' do
       @ds.get(:i).must_equal @ipv6
       @ds.get(:c).must_equal @ipv6nm
       @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv6, :c=>@ipv6nm).must_equal(:i=>@ipv6, :c=>@ipv6nm)
-      @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv4, :c=>@ipv4nm).must_equal nil
+      @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv4, :c=>@ipv4nm).must_be_nil
       @ds.filter(:i=>:$i, :c=>:$c).call(:delete, :i=>@ipv6, :c=>@ipv6nm).must_equal 1
     end
 
     @db.create_table!(:items){column :i, 'inet[]'; column :c, 'cidr[]'; column :m, 'macaddr[]'}
     @ds.call(:insert, {:i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']}, {:i=>:$i, :c=>:$c, :m=>:$m})
     @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:first, :i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']).must_equal(:i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab'])
-    @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:first, :i=>[], :c=>[], :m=>[]).must_equal nil
+    @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:first, :i=>[], :c=>[], :m=>[]).must_be_nil
     @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:delete, :i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']).must_equal 1
   end if (DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || DB.adapter_scheme == :jdbc
 
@@ -3226,7 +3225,7 @@ describe 'PostgreSQL range types' do
     @ds.first.must_be :==, @r
     @ds.filter(h).call(:first, @r).must_be :==, @r
     @ds.filter(h).call(:first, @pgr).must_be :==, @r
-    @ds.filter(h).call(:first, r2).must_equal nil
+    @ds.filter(h).call(:first, r2).must_be_nil
     @ds.filter(h).call(:delete, @r).must_equal 1
 
     @db.create_table!(:items){column :i4, 'int4range[]'; column :i8, 'int8range[]'; column :n, 'numrange[]'; column :d, 'daterange[]'; column :t, 'tsrange[]'; column :tz, 'tstzrange[]'}
@@ -3234,7 +3233,7 @@ describe 'PostgreSQL range types' do
     @ds.call(:insert, @ra, h)
     @ds.filter(h).call(:first, @ra).each{|k, v| v.must_be :==, @ra[k].to_a}
     @ds.filter(h).call(:first, @pgra).each{|k, v| v.must_be :==, @ra[k].to_a}
-    @ds.filter(h).call(:first, r2).must_equal nil
+    @ds.filter(h).call(:first, r2).must_be_nil
     @ds.filter(h).call(:delete, @ra).must_equal 1
   end if (DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || DB.adapter_scheme == :jdbc
 
@@ -3409,13 +3408,13 @@ describe 'PostgreSQL interval types' do
     @ds.call(:insert, {:i=>d}, {:i=>:$i})
     @ds.get(:i).must_equal d
     @ds.filter(:i=>:$i).call(:first, :i=>d).must_equal(:i=>d)
-    @ds.filter(:i=>Sequel.cast(:$i, :interval)).call(:first, :i=>'0').must_equal nil
+    @ds.filter(:i=>Sequel.cast(:$i, :interval)).call(:first, :i=>'0').must_be_nil
     @ds.filter(:i=>:$i).call(:delete, :i=>d).must_equal 1
 
     @db.create_table!(:items){column :i, 'interval[]'}
     @ds.call(:insert, {:i=>[d]}, {:i=>:$i})
     @ds.filter(:i=>:$i).call(:first, :i=>[d]).must_equal(:i=>[d])
-    @ds.filter(:i=>:$i).call(:first, :i=>[]).must_equal nil
+    @ds.filter(:i=>:$i).call(:first, :i=>[]).must_be_nil
     @ds.filter(:i=>:$i).call(:delete, :i=>[d]).must_equal 1
   end if (DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || DB.adapter_scheme == :jdbc
 
@@ -3529,7 +3528,7 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds.call(:insert, {:address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])}, {:address=>:$address, :id=>1})
     @ds.get(:address).must_equal(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345')
     @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345']))[:id].must_equal 1
-    @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])).must_equal nil
+    @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])).must_be_nil
 
     @ds.delete
     @ds.call(:insert, {:address=>Sequel.pg_row([nil, nil, nil])}, {:address=>:$address, :id=>1})
@@ -3541,7 +3540,7 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds.call(:insert, {:employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])])}, {:employees=>:$employees, :id=>1})
     @ds.get(:company).must_equal(:id=>1, :employees=>[{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}])
     @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])]))[:id].must_equal 1
-    @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])])])).must_equal nil
+    @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])])])).must_be_nil
 
     @ds.delete
     @ds.call(:insert, {:employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row([nil, nil, nil])])])}, {:employees=>:$employees, :id=>1})
@@ -3671,7 +3670,7 @@ describe 'PostgreSQL row-valued/composite types' do
       @ds.call(:insert, {:address=>@a}, {:address=>:$address, :id=>1})
       @ds.get(:address).must_equal @a
       @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>@a)[:id].must_equal 1
-      @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Address.new(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12356')).must_equal nil
+      @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Address.new(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12356')).must_be_nil
     end if (DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || DB.adapter_scheme == :jdbc
 
     it 'use arrays of model objects in bound variables' do
@@ -3679,7 +3678,7 @@ describe 'PostgreSQL row-valued/composite types' do
       @ds.call(:insert, {:employees=>@es}, {:employees=>:$employees, :id=>1})
       @ds.get(:company).must_equal Company.new(:id=>1, :employees=>@es)
       @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>@es)[:id].must_equal 1
-      @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])])])).must_equal nil
+      @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])])])).must_be_nil
     end if (DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || DB.adapter_scheme == :jdbc
 
     it 'model typecasting' do
@@ -3822,7 +3821,7 @@ describe "PostgreSQL stored procedures for datasets" do
 
   it "should correctly call stored procedure for inserting record" do
     result = @ds.call_sproc(:insert, :insert_item, 100)
-    result.must_equal nil
+    result.must_be_nil
 
     @ds.call(:all).must_equal [{:id=>1, :numb=>100}]
   end