sequel 5.3.0 → 5.4.0

data/spec/extensions/date_arithmetic_spec.rb

@@ -87,6 +87,10 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
     db.literal(Sequel.date_add(:a, @h1)).must_equal "(CAST(a AS timestamp) + CAST('1 days ' AS interval))"
     db.literal(Sequel.date_add(:a, @h2)).must_equal "(CAST(a AS timestamp) + CAST('1 years 1 months 1 days 1 hours 1 minutes 1 seconds ' AS interval))"
+
+    db.literal(Sequel.date_add(:a, @h0, :cast=>:timestamptz)).must_equal "CAST(a AS timestamptz)"
+    db.literal(Sequel.date_sub(:a, @h0, :cast=>:timestamptz)).must_equal "CAST(a AS timestamptz)"
+    db.literal(Sequel.date_add(:a, @h2, :cast=>:timestamptz)).must_equal "(CAST(a AS timestamptz) + CAST('1 years 1 months 1 days 1 hours 1 minutes 1 seconds ' AS interval))"
   end
 
   it "should correctly literalize on SQLite" do
@@ -101,6 +105,7 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS DATETIME)"
     db.literal(Sequel.date_add(:a, @h1)).must_equal "DATE_ADD(a, INTERVAL 1 DAY)"
     db.literal(Sequel.date_add(:a, @h2)).must_equal "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(a, INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
+    db.literal(Sequel.date_add(:a, @h0, :cast=>:timestamp)).must_equal "CAST(a AS timestamp)"
   end
 
   it "should correctly literalize on HSQLDB" do
@@ -110,6 +115,9 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(CAST(a AS timestamp) AS timestamp)"
     db.literal(Sequel.date_add(:a, @h1)).must_equal "DATE_ADD(CAST(a AS timestamp), INTERVAL 1 DAY)"
     db.literal(Sequel.date_add(:a, @h2)).must_equal "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(CAST(a AS timestamp), INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
+
+    db.literal(Sequel.date_add(:a, @h0, :cast=>:datetime)).must_equal "CAST(CAST(a AS datetime) AS datetime)"
+    db.literal(Sequel.date_add(:a, @h2, :cast=>:datetime)).must_equal "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(CAST(a AS datetime), INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
   end
 
   it "should correctly literalize on MSSQL" do
@@ -117,6 +125,7 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS datetime)"
     db.literal(Sequel.date_add(:A, @h1)).must_equal "DATEADD(day, 1, A)"
     db.literal(Sequel.date_add(:A, @h2)).must_equal "DATEADD(second, 1, DATEADD(minute, 1, DATEADD(hour, 1, DATEADD(day, 1, DATEADD(month, 1, DATEADD(year, 1, A))))))"
+    db.literal(Sequel.date_add(:A, @h0, :cast=>:timestamp)).must_equal "CAST(A AS timestamp)"
   end
 
   it "should correctly literalize on H2" do
@@ -126,6 +135,7 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
     db.literal(Sequel.date_add(:a, @h1)).must_equal "DATEADD('day', 1, a)"
     db.literal(Sequel.date_add(:a, @h2)).must_equal "DATEADD('second', 1, DATEADD('minute', 1, DATEADD('hour', 1, DATEADD('day', 1, DATEADD('month', 1, DATEADD('year', 1, a))))))"
+    db.literal(Sequel.date_add(:a, @h0, :cast=>:datetime)).must_equal "CAST(a AS datetime)"
   end
 
   it "should correctly literalize on access" do
@@ -143,6 +153,7 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:a, @h1)).must_equal "{fn timestampadd(SQL_TSI_DAY, 1, timestamp(a))}"
     db.literal(Sequel.date_add(:a, @h2)).must_equal "{fn timestampadd(SQL_TSI_SECOND, 1, timestamp({fn timestampadd(SQL_TSI_MINUTE, 1, timestamp({fn timestampadd(SQL_TSI_HOUR, 1, timestamp({fn timestampadd(SQL_TSI_DAY, 1, timestamp({fn timestampadd(SQL_TSI_MONTH, 1, timestamp({fn timestampadd(SQL_TSI_YEAR, 1, timestamp(a))}))}))}))}))}))}"
     db.literal(Sequel.date_add(Date.civil(2012, 11, 12), @h1)).must_equal "{fn timestampadd(SQL_TSI_DAY, 1, timestamp((CAST('2012-11-12' AS varchar(255)) || ' 00:00:00')))}"
+    db.literal(Sequel.date_add(:a, @h0, :cast=>:datetime)).must_equal "CAST(a AS datetime)"
   end
 
   it "should correctly literalize on Oracle" do
@@ -150,13 +161,16 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS timestamp)"
     db.literal(Sequel.date_add(:A, @h1)).must_equal "(A + INTERVAL '1' DAY)"
     db.literal(Sequel.date_add(:A, @h2)).must_equal "(A + INTERVAL '1' YEAR + INTERVAL '1' MONTH + INTERVAL '1' DAY + INTERVAL '1' HOUR + INTERVAL '1' MINUTE + INTERVAL '1' SECOND)"
+    db.literal(Sequel.date_add(:A, @h0, :cast=>:datetime)).must_equal "CAST(A AS datetime)"
   end
 
   it "should correctly literalize on DB2" do
     db = dbf.call(:db2)
     db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS timestamp)"
     db.literal(Sequel.date_add(:A, @h1)).must_equal "(CAST(A AS timestamp) + 1 days)"
-    db.literal(Sequel.date_add(:A, @h2)).must_equal "(CAST(A AS timestamp) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
+    db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS timestamp)"
+    db.literal(Sequel.date_add(:A, @h1, :cast=>:datetime)).must_equal "(CAST(A AS datetime) + 1 days)"
+    db.literal(Sequel.date_add(:A, @h2, :cast=>:datetime)).must_equal "(CAST(A AS datetime) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
   end
 
   it "should raise error if literalizing on an unsupported database" do

data/spec/extensions/datetime_parse_to_time_spec.rb

@@ -0,0 +1,169 @@
+require_relative "spec_helper"
+
+describe "datetime_parse_to_time extension" do
+  before(:all) do
+    Sequel.extension :datetime_parse_to_time
+  end
+  after(:all) do
+    # Can't undo the adding of the module to Sequel, so removing the
+    # method in the module is the only way to fix it.
+    Sequel::DateTimeParseToTime.send(:remove_method, :convert_input_timestamp)
+  end
+
+  before do
+    @db = Sequel::Database.new
+    @dataset = @db.dataset.with_extend do
+      def supports_timestamp_timezones?; true end
+      def supports_timestamp_usecs?; false end
+    end
+    @utc_time = Time.utc(2010, 1, 2, 3, 4, 5)
+    @local_time = Time.local(2010, 1, 2, 3, 4, 5)
+    @offset = sprintf("%+03i%02i", *(@local_time.utc_offset/60).divmod(60))
+    @dt_offset = @local_time.utc_offset/Rational(86400, 1)
+    @utc_datetime = DateTime.new(2010, 1, 2, 3, 4, 5)
+    @local_datetime = DateTime.new(2010, 1, 2, 3, 4, 5, @dt_offset)
+  end
+  after do
+    Sequel.default_timezone = nil
+    Sequel.datetime_class = Time
+  end
+  
+  it "should handle conversions during invalid localtimes" do
+    # This only checks of a couple of times that may be invalid.
+    # You can run with TZ=Europe/Berlin or TZ=US/Pacific
+    Sequel.database_timezone = :utc
+    Sequel.database_to_application_timestamp("2017-03-26 02:30:00").getutc.hour.must_equal 2
+    Sequel.database_to_application_timestamp("2017-03-12 02:30:00").getutc.hour.must_equal 2
+  end
+
+  it "should handle an database timezone of :utc when literalizing values" do
+    Sequel.database_timezone = :utc
+    @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
+  end
+  
+  it "should handle an database timezone of :local when literalizing values" do
+    Sequel.database_timezone = :local
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05#{@offset}'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5, @dt_offset)).must_equal "'2010-01-02 03:04:05#{@offset}'"
+  end
+  
+  it "should have Database#timezone override Sequel.database_timezone" do
+    Sequel.database_timezone = :local
+    @db.timezone = :utc
+    @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
+
+    Sequel.database_timezone = :utc
+    @db.timezone = :local
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05#{@offset}'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5, @dt_offset)).must_equal "'2010-01-02 03:04:05#{@offset}'"
+  end
+  
+  it "should handle converting database timestamps into application timestamps" do
+    Sequel.database_timezone = :utc
+    Sequel.application_timezone = :local
+    t = Time.now.utc
+    Sequel.database_to_application_timestamp(t).to_s.must_equal t.getlocal.to_s
+    Sequel.database_to_application_timestamp(t.to_s).to_s.must_equal t.getlocal.to_s
+    Sequel.database_to_application_timestamp(t.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal t.getlocal.to_s
+    
+    Sequel.datetime_class = DateTime
+    dt = DateTime.now
+    dt2 = dt.new_offset(0)
+    Sequel.database_to_application_timestamp(dt2).to_s.must_equal dt.to_s
+    Sequel.database_to_application_timestamp(dt2.to_s).to_s.must_equal dt.to_s
+    Sequel.database_to_application_timestamp(dt2.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal dt.to_s
+    
+    Sequel.datetime_class = Time
+    Sequel.database_timezone = :local
+    Sequel.application_timezone = :utc
+    Sequel.database_to_application_timestamp(t.getlocal).to_s.must_equal t.to_s
+    Sequel.database_to_application_timestamp(t.getlocal.to_s).to_s.must_equal t.to_s
+    Sequel.database_to_application_timestamp(t.getlocal.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal t.to_s
+    
+    Sequel.datetime_class = DateTime
+    Sequel.database_to_application_timestamp(dt).to_s.must_equal dt2.to_s
+    Sequel.database_to_application_timestamp(dt.to_s).to_s.must_equal dt2.to_s
+    Sequel.database_to_application_timestamp(dt.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal dt2.to_s
+  end
+  
+  it "should handle typecasting timestamp columns" do
+    Sequel.typecast_timezone = :utc
+    Sequel.application_timezone = :local
+    t = Time.now.utc
+    @db.typecast_value(:datetime, t).to_s.must_equal t.getlocal.to_s
+    @db.typecast_value(:datetime, t.to_s).to_s.must_equal t.getlocal.to_s
+    @db.typecast_value(:datetime, t.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal t.getlocal.to_s
+    
+    Sequel.datetime_class = DateTime
+    dt = DateTime.now
+    dt2 = dt.new_offset(0)
+    @db.typecast_value(:datetime, dt2).to_s.must_equal dt.to_s
+    @db.typecast_value(:datetime, dt2.to_s).to_s.must_equal dt.to_s
+    @db.typecast_value(:datetime, dt2.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal dt.to_s
+    
+    Sequel.datetime_class = Time
+    Sequel.typecast_timezone = :local
+    Sequel.application_timezone = :utc
+    @db.typecast_value(:datetime, t.getlocal).to_s.must_equal t.to_s
+    @db.typecast_value(:datetime, t.getlocal.to_s).to_s.must_equal t.to_s
+    @db.typecast_value(:datetime, t.getlocal.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal t.to_s
+    
+    Sequel.datetime_class = DateTime
+    @db.typecast_value(:datetime, dt).to_s.must_equal dt2.to_s
+    @db.typecast_value(:datetime, dt.to_s).to_s.must_equal dt2.to_s
+    @db.typecast_value(:datetime, dt.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal dt2.to_s
+  end
+  
+  it "should handle converting database timestamp columns from an array of values" do
+    Sequel.database_timezone = :utc
+    Sequel.application_timezone = :local
+    t = Time.now.utc
+    Sequel.database_to_application_timestamp([t.year, t.mon, t.day, t.hour, t.min, t.sec]).to_s.must_equal t.getlocal.to_s
+    
+    Sequel.datetime_class = DateTime
+    dt = DateTime.now
+    dt2 = dt.new_offset(0)
+    Sequel.database_to_application_timestamp([dt2.year, dt2.mon, dt2.day, dt2.hour, dt2.min, dt2.sec]).to_s.must_equal dt.to_s
+    
+    Sequel.datetime_class = Time
+    Sequel.database_timezone = :local
+    Sequel.application_timezone = :utc
+    t = t.getlocal
+    Sequel.database_to_application_timestamp([t.year, t.mon, t.day, t.hour, t.min, t.sec]).to_s.must_equal t.getutc.to_s
+    
+    Sequel.datetime_class = DateTime
+    Sequel.database_to_application_timestamp([dt.year, dt.mon, dt.day, dt.hour, dt.min, dt.sec]).to_s.must_equal dt2.to_s
+  end
+  
+  it "should raise an InvalidValue error when an error occurs while converting a timestamp" do
+    proc{Sequel.database_to_application_timestamp([0, 0, 0, 0, 0, 0])}.must_raise(Sequel::InvalidValue)
+  end
+  
+  it "should raise an error when attempting to typecast to a timestamp from an unsupported type" do
+    proc{Sequel.database_to_application_timestamp(Object.new)}.must_raise(Sequel::InvalidValue)
+  end
+
+  it "should raise an InvalidValue error when the DateTime class is used and when a bad application timezone is used when attempting to convert timestamps" do
+    Sequel.application_timezone = :blah
+    Sequel.datetime_class = DateTime
+    proc{Sequel.database_to_application_timestamp('2009-06-01 10:20:30')}.must_raise(Sequel::InvalidValue)
+  end
+  
+  it "should raise an InvalidValue error when the DateTime class is used and when a bad database timezone is used when attempting to convert timestamps" do
+    Sequel.database_timezone = :blah
+    Sequel.datetime_class = DateTime
+    proc{Sequel.database_to_application_timestamp('2009-06-01 10:20:30')}.must_raise(Sequel::InvalidValue)
+  end
+
+  it "should have Sequel.default_timezone= should set all other timezones" do
+    Sequel.database_timezone.must_be_nil
+    Sequel.application_timezone.must_be_nil
+    Sequel.typecast_timezone.must_be_nil
+    Sequel.default_timezone = :utc
+    Sequel.database_timezone.must_equal :utc
+    Sequel.application_timezone.must_equal :utc
+    Sequel.typecast_timezone.must_equal :utc
+  end
+end

data/spec/extensions/index_caching_spec.rb

@@ -0,0 +1,66 @@
+require_relative "spec_helper"
+
+describe "index_caching extension" do
+  before do
+    @db = Sequel.connect('mock://postgres').extension(:index_caching)
+    @indexes = {'"table"'=>{:table_idx_unique=>{:columns=>[:first_col, :second_col], :unique=>true, :deferrable=>nil}}}
+    @filename = "spec/files/test_indexes_#$$.dump"
+    @db.instance_variable_set(:@indexes, @indexes)
+  end
+  after do
+    File.delete(@filename) if File.exist?(@filename)
+  end
+
+  it "#indexes should return cached index information" do
+    @db.indexes(:table).must_equal @indexes['"table"']
+    @db.indexes(:table, {}).must_equal @indexes['"table"']
+  end 
+
+  it "#indexes should skip cached information if given options" do
+    @db.indexes(:table, :schema=>:b).must_equal({})
+  end 
+
+  it "Database should remove cached indexes when schema is changed" do
+    @db.create_table(:table){Integer :a}
+    @db.indexes(:table).must_equal({})
+  end
+
+  it "Database#freeze should allow cached information to work" do
+    @db.freeze.indexes(:table).must_equal @indexes['"table"']
+  end
+  
+  it "Database#freeze should allow removing index information" do
+    @db.freeze
+    @db.create_table(:table){Integer :a}
+    @db.indexes(:table).must_equal({})
+  end
+
+  it "Database#dump_index_cache should dump the index cache to the given file" do
+    File.exist?(@filename).must_equal false
+    @db.dump_index_cache(@filename)
+    File.exist?(@filename).must_equal true
+    File.size(@filename).must_be :>,  0
+  end
+
+  it "Database#load_index_cache should load the index cache from the given file dumped by #dump_index_cache" do
+    @db.dump_index_cache(@filename)
+    db = Sequel::Database.new.extension(:index_caching)
+    db.load_index_cache(@filename)
+    db.extension(:index_caching)
+    @db.instance_variable_get(:@indexes).must_equal @indexes
+  end
+
+  it "Database#dump_index_cache? should dump the index cache to the given file unless the file exists" do
+    File.open(@filename, 'wb'){|f|}
+    File.size(@filename).must_equal 0
+    @db.dump_index_cache?(@filename)
+    File.size(@filename).must_equal 0
+  end
+
+  it "Database#load_index_cache? should load the index cache from the given file if it exists" do
+    db = Sequel::Database.new.extension(:index_caching)
+    File.exist?(@filename).must_equal false
+    db.load_index_cache?(@filename)
+    db.instance_variable_get(:@indexes).must_equal({})
+  end
+end

data/spec/extensions/json_serializer_spec.rb

@@ -187,6 +187,11 @@ describe "Sequel::Plugins::JsonSerializer" do
     Album.array_from_json(Album.dataset.to_json(:only=>:name)).must_equal [Album.load(:name=>@album.name)]
   end
 
+  it "should have dataset to_json method work with eager_graph datasets" do
+    ds = Album.dataset.eager_graph(:artist).with_fetch(:id=>1, :name=>'RF', :artist_id=>2, :artist_id_0=>2, :artist_name=>'YM')
+    Sequel.parse_json(ds.to_json(:only=>:name, :include=>{:artist=>{:only=>:name}})).must_equal [{"name"=>"RF", "artist"=>{"name"=>"YM"}}]
+  end
+
   it "should have dataset to_json method work with naked datasets" do
     ds = Album.dataset.naked.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
     Sequel.parse_json(ds.to_json).must_equal [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]

data/spec/extensions/null_dataset_spec.rb

@@ -21,6 +21,11 @@ describe "null_dataset extension" do
     @i.must_equal 0
   end
 
+  it "nullify should be a cached dataset" do
+    ds = @db[:table]
+    ds.nullify.object_id.must_equal(ds.nullify.object_id)
+  end
+
   it "should make insert be a noop" do
     @ds.insert(1).must_be_nil
   end

data/spec/extensions/pg_extended_date_support_spec.rb

@@ -105,6 +105,10 @@ describe "pg_extended_date_support extension" do
     @db.literal(-Date::Infinity.new).must_equal "'-infinity'"
   end
 
+  it "should raise errors for literalizing random Objects" do
+    proc{@db.literal(Object.new)}.must_raise Sequel::Error
+  end
+
   it "should format BC dates" do
     @db.literal(Date.new(-1091, 10, 20)).must_equal "'1092-10-20 BC'"
     @db.literal(Date.new(1092, 10, 20)).must_equal "'1092-10-20'"

data/spec/extensions/pg_timestamptz_spec.rb

@@ -0,0 +1,17 @@
+require_relative "spec_helper"
+
+describe "pg_timestamptz extension" do
+  before do
+    @db = Sequel.mock(:host=>'postgres').extension :pg_timestamptz
+  end
+
+  it "should use timestamptz as default timestamp type" do
+    @db.create_table(:t){Time :t; DateTime :tz; Time :ot, :only_time=>true}
+    @db.sqls.must_equal ['CREATE TABLE "t" ("t" timestamptz, "tz" timestamptz, "ot" time)']
+  end
+
+  it "should use timestamptz when casting" do
+    @db.get(Sequel.cast('a', Time))
+    @db.sqls.must_equal ["SELECT CAST('a' AS timestamptz) AS \"v\" LIMIT 1"]
+  end
+end

data/spec/extensions/xml_serializer_spec.rb

@@ -172,6 +172,13 @@ describe "Sequel::Plugins::XmlSerializer" do
     x.first.albums.must_equal [a]
   end
 
+  it "should work correctly for eager graphed datasets" do
+    ds = Album.dataset.eager_graph(:artist).with_fetch(:id=>1, :name=>'RF', :artist_id=>2, :artist_id_0=>2, :artist_name=>'YJM')
+    albums = Album.array_from_xml(ds.to_xml(:only=>:name, :include=>{:artist=>{:only=>:name}}), :associations=>:artist)
+    albums.must_equal [Album.load(:name=>@album.name)]
+    albums.first.artist.must_equal Artist.load(:name=>@artist.name)
+  end
+
   it "should raise an error if the dataset does not have a row_proc" do
     proc{Album.dataset.naked.to_xml}.must_raise(Sequel::Error)
   end

data/spec/integration/dataset_test.rb

@@ -1217,6 +1217,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.as_hash([:a, :c], :b).must_equal([1, 3]=>2, [5, 7]=>6)
     @ds.as_hash(:a, [:b, :c]).must_equal(1=>[2, 3], 5=>[6, 7])
     @ds.as_hash([:a, :c], [:b, :d]).must_equal([1, 3]=>[2, 4], [5, 7]=>[6, 8])
+    @ds.extension(:null_dataset).nullify.as_hash([:a, :c], [:b, :d]).must_equal({})
 
     @ds.as_hash(:a, :b, :hash => (tmp = {})).must_be_same_as(tmp)
   end
@@ -1232,6 +1233,7 @@ describe "Sequel::Dataset convenience methods" do
     ds.to_hash_groups([:a, :c], :d).must_equal([1, 3]=>[4, 9], [5, 7]=>[8])
     ds.to_hash_groups(:a, [:b, :d]).must_equal(1=>[[2, 4], [2, 9]], 5=>[[6, 8]])
     ds.to_hash_groups([:a, :c], [:b, :d]).must_equal([1, 3]=>[[2, 4], [2, 9]], [5, 7]=>[[6, 8]])
+    @ds.extension(:null_dataset).nullify.to_hash_groups([:a, :c], [:b, :d]).must_equal({})
 
     ds.to_hash_groups(:a, :d, :hash => (tmp = {})).must_be_same_as(tmp)
   end
@@ -1241,6 +1243,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.select_map(:b).must_equal [2, 6]
     @ds.select_map([:a]).must_equal [[1], [5]]
     @ds.select_map([:a, :b]).must_equal [[1, 2], [5, 6]]
+    @ds.extension(:null_dataset).nullify.select_map([:a, :b]).must_equal []
 
     @ds.select_map(Sequel[:a].as(:e)).must_equal [1, 5]
     @ds.select_map(Sequel[:b].as(:e)).must_equal [2, 6]
@@ -1258,6 +1261,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.select_order_map(Sequel.qualify(:a, :b).as(:e)).must_equal [2, 6]
     @ds.select_order_map([:a]).must_equal [[1], [5]]
     @ds.select_order_map([Sequel.desc(:a), :b]).must_equal [[5, 6], [1, 2]]
+    @ds.extension(:null_dataset).nullify.select_order_map(:a).must_equal []
 
     @ds.select_order_map(Sequel[:a].as(:e)).must_equal [1, 5]
     @ds.select_order_map(Sequel[:b].as(:e)).must_equal [2, 6]
@@ -1278,6 +1282,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.select_hash(:a, [:b, :c]).must_equal(1=>[2, 3], 5=>[6, 7])
     @ds.select_hash([:a, :c], [:b, :d]).must_equal([1, 3]=>[2, 4], [5, 7]=>[6, 8])
     @ds.select_hash(:a, :b, :hash => (tmp = {})).must_be_same_as(tmp)
+    @ds.extension(:null_dataset).nullify.select_hash(:a, :b).must_equal({})
   end
 
   it "should have working #select_hash_groups" do
@@ -1292,6 +1297,7 @@ describe "Sequel::Dataset convenience methods" do
     ds.select_hash_groups(:a, [:b, :d]).must_equal(1=>[[2, 4], [2, 9]], 5=>[[6, 8]])
     ds.select_hash_groups([:a, :c], [:b, :d]).must_equal([1, 3]=>[[2, 4], [2, 9]], [5, 7]=>[[6, 8]])
     ds.select_hash_groups(:a, :d, :hash => (tmp = {})).must_be_same_as(tmp)
+    @ds.extension(:null_dataset).nullify.select_hash_groups(:a, :d).must_equal({})
   end
 end
 

data/spec/integration/prepared_statement_test.rb

@@ -319,7 +319,7 @@ describe "Bound Argument Types" do
       TrueClass :b
     end
     @ds = @db[:items]
-    @vs = {:d=>Date.civil(2010, 10, 11), :dt=>DateTime.civil(2010, 10, 12, 13, 14, 15), :f=>1.0, :s=>'str', :t=>Time.at(20101010), :file=>Sequel::SQL::Blob.new('blob'), :b=>true}
+    @vs = {:d=>Date.civil(2010, 10, 11), :dt=>DateTime.civil(2010, 10, 12, 13, 14, 15), :f=>1.0, :s=>'str', :t=>Time.at(Time.now.to_i), :file=>Sequel::SQL::Blob.new('blob'), :b=>true}
   end
   before do
     @ds.delete

data/spec/integration/schema_test.rb

@@ -189,23 +189,25 @@ describe "Database index parsing" do
   end
 
   it "should parse indexes into a hash" do
-    # Delete :deferrable entry, since not all adapters implement it
-    f = lambda{h = DB.indexes(:items); h.values.each{|h2| h2.delete(:deferrable)}; h}
-
-    DB.create_table!(:items){Integer :n; Integer :a}
-    f.call.must_equal({})
-    DB.add_index(:items, :n)
-    f.call.must_equal(:items_n_index=>{:columns=>[:n], :unique=>false})
-    DB.drop_index(:items, :n)
-    f.call.must_equal({})
-    DB.add_index(:items, :n, :unique=>true, :name=>:blah_blah_index)
-    f.call.must_equal(:blah_blah_index=>{:columns=>[:n], :unique=>true})
-    DB.add_index(:items, [:n, :a])
-    f.call.must_equal(:blah_blah_index=>{:columns=>[:n], :unique=>true}, :items_n_a_index=>{:columns=>[:n, :a], :unique=>false})
-    DB.drop_index(:items, :n, :name=>:blah_blah_index)
-    f.call.must_equal(:items_n_a_index=>{:columns=>[:n, :a], :unique=>false})
-    DB.drop_index(:items, [:n, :a])
-    f.call.must_equal({})
+    [:items, Sequel.identifier(:items)].each do |table|
+      # Delete :deferrable entry, since not all adapters implement it
+      f = lambda{h = DB.indexes(table); h.values.each{|h2| h2.delete(:deferrable)}; h}
+
+      DB.create_table!(table){Integer :n; Integer :a}
+      f.call.must_equal({})
+      DB.add_index(table, :n)
+      f.call.must_equal(:items_n_index=>{:columns=>[:n], :unique=>false})
+      DB.drop_index(table, :n)
+      f.call.must_equal({})
+      DB.add_index(table, :n, :unique=>true, :name=>:blah_blah_index)
+      f.call.must_equal(:blah_blah_index=>{:columns=>[:n], :unique=>true})
+      DB.add_index(table, [:n, :a])
+      f.call.must_equal(:blah_blah_index=>{:columns=>[:n], :unique=>true}, :items_n_a_index=>{:columns=>[:n, :a], :unique=>false})
+      DB.drop_index(table, :n, :name=>:blah_blah_index)
+      f.call.must_equal(:items_n_a_index=>{:columns=>[:n, :a], :unique=>false})
+      DB.drop_index(table, [:n, :a])
+      f.call.must_equal({})
+    end
   end
   
   it "should not include a primary key index" do