sequel 3.38.0 → 3.39.0

data/spec/adapters/sqlite_spec.rb

@@ -18,6 +18,7 @@ describe "An SQLite database" do
     @fk = @db.foreign_keys
   end
   after do
+    @db.drop_table?(:fk)
     @db.foreign_keys = @fk
     @db.case_sensitive_like = true
     Sequel.datetime_class = Time
@@ -74,16 +75,14 @@ describe "An SQLite database" do
     @db.foreign_keys = false
   end
   
-  if SQLITE_DB.sqlite_version >= 30619
-    specify "should enforce foreign key integrity if foreign_keys pragma is set" do
-      @db.foreign_keys = true
-      @db.create_table!(:fk){primary_key :id; foreign_key :parent_id, :fk}
-      @db[:fk].insert(1, nil)
-      @db[:fk].insert(2, 1)
-      @db[:fk].insert(3, 3)
-      proc{@db[:fk].insert(4, 5)}.should raise_error(Sequel::Error)
-    end
-  end
+  specify "should enforce foreign key integrity if foreign_keys pragma is set" do
+    @db.foreign_keys = true
+    @db.create_table!(:fk){primary_key :id; foreign_key :parent_id, :fk}
+    @db[:fk].insert(1, nil)
+    @db[:fk].insert(2, 1)
+    @db[:fk].insert(3, 3)
+    proc{@db[:fk].insert(4, 5)}.should raise_error(Sequel::Error)
+  end if SQLITE_DB.sqlite_version >= 30619
   
   specify "should not enforce foreign key integrity if foreign_keys pragma is unset" do
     @db.foreign_keys = false
@@ -93,24 +92,22 @@ describe "An SQLite database" do
   end
   
   specify "should support a use_timestamp_timezones setting" do
-    @db.create_table!(:time){Time :time}
-    @db[:time].insert(Time.now)
-    @db[:time].get(Sequel.cast(:time, String)).should =~ /[-+]\d\d\d\d\z/
+    @db.create_table!(:fk){Time :time}
+    @db[:fk].insert(Time.now)
+    @db[:fk].get(Sequel.cast(:time, String)).should =~ /[-+]\d\d\d\d\z/
     @db.use_timestamp_timezones = false
-    @db[:time].delete
-    @db[:time].insert(Time.now)
-    @db[:time].get(Sequel.cast(:time, String)).should_not =~ /[-+]\d\d\d\d\z/
+    @db[:fk].delete
+    @db[:fk].insert(Time.now)
+    @db[:fk].get(Sequel.cast(:time, String)).should_not =~ /[-+]\d\d\d\d\z/
     @db.use_timestamp_timezones = true
   end
   
   specify "should provide a list of existing tables" do
-    @db.drop_table?(:testing)
+    @db.drop_table?(:fk)
     @db.tables.should be_a_kind_of(Array)
-    @db.tables.should_not include(:testing)
-    @db.create_table! :testing do
-      text :name
-    end
-    @db.tables.should include(:testing)
+    @db.tables.should_not include(:fk)
+    @db.create_table!(:fk){String :name}
+    @db.tables.should include(:fk)
   end
 
   specify "should support getting and setting the synchronous pragma" do
@@ -136,23 +133,23 @@ describe "An SQLite database" do
   end
   
   cspecify "should support timestamps and datetimes and respect datetime_class", :do, :jdbc, :amalgalite, :swift do
-    @db.create_table!(:time){timestamp :t; datetime :d}
+    @db.create_table!(:fk){timestamp :t; datetime :d}
     t1 = Time.at(1)
-    @db[:time] << {:t => t1, :d => t1}
-    @db[:time].map(:t).should == [t1]
-    @db[:time].map(:d).should == [t1]
+    @db[:fk] << {:t => t1, :d => t1}
+    @db[:fk].map(:t).should == [t1]
+    @db[:fk].map(:d).should == [t1]
     Sequel.datetime_class = DateTime
     t2 = Sequel.string_to_datetime(t1.iso8601)
-    @db[:time].map(:t).should == [t2]
-    @db[:time].map(:d).should == [t2]
+    @db[:fk].map(:t).should == [t2]
+    @db[:fk].map(:d).should == [t2]
   end
   
   specify "should support sequential primary keys" do
-    @db.create_table!(:with_pk) {primary_key :id; text :name}
-    @db[:with_pk] << {:name => 'abc'}
-    @db[:with_pk] << {:name => 'def'}
-    @db[:with_pk] << {:name => 'ghi'}
-    @db[:with_pk].order(:name).all.should == [
+    @db.create_table!(:fk) {primary_key :id; text :name}
+    @db[:fk] << {:name => 'abc'}
+    @db[:fk] << {:name => 'def'}
+    @db[:fk] << {:name => 'ghi'}
+    @db[:fk].order(:name).all.should == [
       {:id => 1, :name => 'abc'},
       {:id => 2, :name => 'def'},
       {:id => 3, :name => 'ghi'}
@@ -160,8 +157,21 @@ describe "An SQLite database" do
   end
   
   specify "should correctly parse the schema" do
-    @db.create_table!(:time2) {timestamp :t}
-    @db.schema(:time2, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp", :primary_key=>false}]]
+    @db.create_table!(:fk) {timestamp :t}
+    @db.schema(:fk, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp", :primary_key=>false}]]
+  end
+
+  specify "should handle and return BigDecimal values for numeric columns" do
+    SQLITE_DB.create_table!(:fk){numeric :d}
+    d = SQLITE_DB[:fk]
+    d.insert(:d=>BigDecimal.new('80.0'))
+    d.insert(:d=>BigDecimal.new('NaN'))
+    d.insert(:d=>BigDecimal.new('Infinity'))
+    d.insert(:d=>BigDecimal.new('-Infinity'))
+    ds = d.all
+    ds.shift.should == {:d=>BigDecimal.new('80.0')}
+    ds.map{|x| x[:d].to_s}.should == %w'NaN Infinity -Infinity'
+    SQLITE_DB
   end
 end
 
@@ -265,20 +275,6 @@ describe "An SQLite dataset" do
   end
 end
 
-describe "An SQLite numeric column" do
-  specify "should handle and return BigDecimal values" do
-    SQLITE_DB.create_table!(:d){numeric :d}
-    d = SQLITE_DB[:d]
-    d.insert(:d=>BigDecimal.new('80.0'))
-    d.insert(:d=>BigDecimal.new('NaN'))
-    d.insert(:d=>BigDecimal.new('Infinity'))
-    d.insert(:d=>BigDecimal.new('-Infinity'))
-    ds = d.all
-    ds.shift.should == {:d=>BigDecimal.new('80.0')}
-    ds.map{|x| x[:d].to_s}.should == %w'NaN Infinity -Infinity'
-  end
-end
-
 describe "An SQLite dataset AS clause" do
   specify "should use a string literal for :col___alias" do
     SQLITE_DB.literal(:c___a).should == "`c` AS 'a'"
@@ -407,6 +403,9 @@ describe "A SQLite database" do
       integer :value
     end
   end
+  after do
+    @db.drop_table?(:test2)
+  end
 
   specify "should support add_column operations" do
     @db.add_column :test2, :xyz, :text
@@ -533,6 +532,7 @@ describe "A SQLite database" do
     @db.from(table_name).all.should == [{:"s s"=>1}]
     @db.rename_column table_name, :"s s", :"t t"
     @db.from(table_name).all.should == [{:"t t"=>1}]
+    @db.drop_table?(table_name)
   end
   
   specify "should choose a temporary table name that isn't already used when dropping or renaming columns" do
@@ -574,6 +574,7 @@ describe "A SQLite database" do
     @db[:test3_backup1].columns.should == [:k]
     @db[:test3_backup2].columns.should == [:l]
     @db.loggers.delete(l)
+    @db.drop_table?(:test3, :test3_backup0, :test3_backup1, :test3_backup2)
   end
   
   specify "should support add_index" do

data/spec/core/connection_pool_spec.rb

@@ -365,6 +365,28 @@ shared_examples_for "A threaded connection pool" do
       Thread.new{@pool.hold{|cc2| cc2.should == c}}
     end
   end
+
+  specify "should not store connections if :connection_handling=>:disconnect" do
+    @pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:connection_handling=>:disconnect)){@invoked_count += 1}
+    d = []
+    @pool.disconnection_proc = proc{|c| d << c}
+    c = @pool.hold do |cc|
+      cc.should == 1
+      Thread.new{@pool.hold{|cc2| cc2.should == 2}}.join
+      d.should == [2]
+      @pool.hold{|cc3| cc3.should == 1}
+    end
+    @pool.size.should == 0
+    d.should == [2, 1]
+
+    @pool.hold{|cc| cc.should == 3}
+    @pool.size.should == 0
+    d.should == [2, 1, 3]
+
+    @pool.hold{|cc| cc.should == 4}
+    @pool.size.should == 0
+    d.should == [2, 1, 3, 4]
+  end
 end
 
 describe "Threaded Unsharded Connection Pool" do

data/spec/core/database_spec.rb

@@ -1726,16 +1726,17 @@ describe "Database#typecast_value" do
   end
 
   specify "should typecast datetime values to Sequel.datetime_class with correct timezone handling" do
-    t = Time.utc(2011, 1, 2, 3, 4, 5) # UTC Time
-    t2 = Time.mktime(2011, 1, 2, 3, 4, 5) # Local Time
-    t3 = Time.utc(2011, 1, 2, 3, 4, 5) - (t - t2) # Local Time in UTC Time
-    t4 = Time.mktime(2011, 1, 2, 3, 4, 5) + (t - t2) # UTC Time in Local Time
-    dt = DateTime.civil(2011, 1, 2, 3, 4, 5)
+    t = Time.utc(2011, 1, 2, 3, 4, 5, 500000) # UTC Time
+    t2 = Time.mktime(2011, 1, 2, 3, 4, 5, 500000) # Local Time
+    t3 = Time.utc(2011, 1, 2, 3, 4, 5, 500000) - (t - t2) # Local Time in UTC Time
+    t4 = Time.mktime(2011, 1, 2, 3, 4, 5, 500000) + (t - t2) # UTC Time in Local Time
+    secs = defined?(Rational) ? Rational(11, 2) : 5.5
     r1 = defined?(Rational) ? Rational(t2.utc_offset, 86400) : t2.utc_offset/86400.0
     r2 = defined?(Rational) ? Rational((t - t2).to_i, 86400) : (t - t2).to_i/86400.0
-    dt2 = DateTime.civil(2011, 1, 2, 3, 4, 5, r1)
-    dt3 = DateTime.civil(2011, 1, 2, 3, 4, 5) - r2
-    dt4 = DateTime.civil(2011, 1, 2, 3, 4, 5, r1) + r2
+    dt = DateTime.civil(2011, 1, 2, 3, 4, secs)
+    dt2 = DateTime.civil(2011, 1, 2, 3, 4, secs, r1)
+    dt3 = DateTime.civil(2011, 1, 2, 3, 4, secs) - r2
+    dt4 = DateTime.civil(2011, 1, 2, 3, 4, secs, r1) + r2
 
     t.should == t4
     t2.should == t3
@@ -1751,25 +1752,26 @@ describe "Database#typecast_value" do
         v.offset.should == o.offset
       end
     end
+    @db.extend_datasets(Module.new{def supports_timestamp_timezones?; true; end})
     begin
       @db.typecast_value(:datetime, dt).should == t
       @db.typecast_value(:datetime, dt2).should == t2
       @db.typecast_value(:datetime, t).should == t
       @db.typecast_value(:datetime, t2).should == t2
-      @db.typecast_value(:datetime, dt.to_s).should == t
-      @db.typecast_value(:datetime, dt.strftime('%F %T')).should == t2
+      @db.typecast_value(:datetime, @db.literal(dt)[1...-1]).should == t
+      @db.typecast_value(:datetime, dt.strftime('%F %T.%N')).should == t2
       @db.typecast_value(:datetime, Date.civil(2011, 1, 2)).should == Time.mktime(2011, 1, 2, 0, 0, 0)
-      @db.typecast_value(:datetime, :year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec).should == t2
+      @db.typecast_value(:datetime, :year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000).should == t2
 
       Sequel.datetime_class = DateTime
       @db.typecast_value(:datetime, dt).should == dt
       @db.typecast_value(:datetime, dt2).should == dt2
       @db.typecast_value(:datetime, t).should == dt
       @db.typecast_value(:datetime, t2).should == dt2
-      @db.typecast_value(:datetime, dt.to_s).should == dt
-      @db.typecast_value(:datetime, dt.strftime('%F %T')).should == dt
+      @db.typecast_value(:datetime, @db.literal(dt)[1...-1]).should == dt
+      @db.typecast_value(:datetime, dt.strftime('%F %T.%N')).should == dt
       @db.typecast_value(:datetime, Date.civil(2011, 1, 2)).should == DateTime.civil(2011, 1, 2, 0, 0, 0)
-      @db.typecast_value(:datetime, :year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec).should == dt
+      @db.typecast_value(:datetime, :year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000).should == dt
 
       Sequel.application_timezone = :utc
       Sequel.typecast_timezone = :local
@@ -1778,20 +1780,20 @@ describe "Database#typecast_value" do
       check[dt2, t3]
       check[t, t]
       check[t2, t3]
-      check[dt.to_s, t]
-      check[dt.strftime('%F %T'), t3]
+      check[@db.literal(dt)[1...-1], t]
+      check[dt.strftime('%F %T.%N'), t3]
       check[Date.civil(2011, 1, 2), Time.utc(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec}, t3]
+      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, t3]
 
       Sequel.datetime_class = DateTime
       check[dt, dt]
       check[dt2, dt3]
       check[t, dt]
       check[t2, dt3]
-      check[dt.to_s, dt]
-      check[dt.strftime('%F %T'), dt3]
+      check[@db.literal(dt)[1...-1], dt]
+      check[dt.strftime('%F %T.%N'), dt3]
       check[Date.civil(2011, 1, 2), DateTime.civil(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec}, dt3]
+      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, dt3]
 
       Sequel.typecast_timezone = :utc
       Sequel.datetime_class = Time
@@ -1799,20 +1801,20 @@ describe "Database#typecast_value" do
       check[dt2, t3]
       check[t, t]
       check[t2, t3]
-      check[dt.to_s, t]
-      check[dt.strftime('%F %T'), t]
+      check[@db.literal(dt)[1...-1], t]
+      check[dt.strftime('%F %T.%N'), t]
       check[Date.civil(2011, 1, 2), Time.utc(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec}, t]
+      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, t]
 
       Sequel.datetime_class = DateTime
       check[dt, dt]
       check[dt2, dt3]
       check[t, dt]
       check[t2, dt3]
-      check[dt.to_s, dt]
-      check[dt.strftime('%F %T'), dt]
+      check[@db.literal(dt)[1...-1], dt]
+      check[dt.strftime('%F %T.%N'), dt]
       check[Date.civil(2011, 1, 2), DateTime.civil(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec}, dt]
+      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, dt]
 
       Sequel.application_timezone = :local
       Sequel.datetime_class = Time
@@ -1820,20 +1822,20 @@ describe "Database#typecast_value" do
       check[dt2, t2]
       check[t, t4]
       check[t2, t2]
-      check[dt.to_s, t4]
-      check[dt.strftime('%F %T'), t4]
+      check[@db.literal(dt)[1...-1], t4]
+      check[dt.strftime('%F %T.%N'), t4]
       check[Date.civil(2011, 1, 2), Time.local(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec}, t4]
+      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, t4]
 
       Sequel.datetime_class = DateTime
       check[dt, dt4]
       check[dt2, dt2]
       check[t, dt4]
       check[t2, dt2]
-      check[dt.to_s, dt4]
-      check[dt.strftime('%F %T'), dt4]
+      check[@db.literal(dt)[1...-1], dt4]
+      check[dt.strftime('%F %T.%N'), dt4]
       check[Date.civil(2011, 1, 2), DateTime.civil(2011, 1, 2, 0, 0, 0, r1)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec}, dt4]
+      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, dt4]
 
       Sequel.typecast_timezone = :local
       Sequel.datetime_class = Time
@@ -1841,20 +1843,20 @@ describe "Database#typecast_value" do
       check[dt2, t2]
       check[t, t4]
       check[t2, t2]
-      check[dt.to_s, t4]
-      check[dt.strftime('%F %T'), t2]
+      check[@db.literal(dt)[1...-1], t4]
+      check[dt.strftime('%F %T.%N'), t2]
       check[Date.civil(2011, 1, 2), Time.local(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec}, t2]
+      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, t2]
 
       Sequel.datetime_class = DateTime
       check[dt, dt4]
       check[dt2, dt2]
       check[t, dt4]
       check[t2, dt2]
-      check[dt.to_s, dt4]
-      check[dt.strftime('%F %T'), dt2]
+      check[@db.literal(dt)[1...-1], dt4]
+      check[dt.strftime('%F %T.%N'), dt2]
       check[Date.civil(2011, 1, 2), DateTime.civil(2011, 1, 2, 0, 0, 0, r1)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec}, dt2]
+      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, dt2]
 
     ensure
       Sequel.default_timezone = nil
@@ -2063,8 +2065,7 @@ end
 describe "Database#column_schema_to_ruby_default" do
   specify "should handle converting many default formats" do
     db = Sequel::Database.new
-    m = db.method(:column_schema_to_ruby_default)
-    p = lambda{|d,t| m.call(d,t)}
+    p = lambda{|d,t| db.send(:column_schema_to_ruby_default, d, t)}
     p[nil, :integer].should be_nil
     p['1', :integer].should == 1
     p['-1', :integer].should == -1
@@ -2085,14 +2086,20 @@ describe "Database#column_schema_to_ruby_default" do
     p["'\\a''b'", :string].should == "\\a'b"
     p["'NULL'", :string].should == "NULL"
     p["'2009-10-29'", :date].should == Date.new(2009,10,29)
-    p["CURRENT_TIMESTAMP", :date].should be_nil
-    p["today()", :date].should be_nil
+    p["CURRENT_TIMESTAMP", :date].should == Sequel::CURRENT_DATE
+    p["CURRENT_DATE", :date].should == Sequel::CURRENT_DATE
+    p["now()", :date].should == Sequel::CURRENT_DATE
+    p["getdate()", :date].should == Sequel::CURRENT_DATE
+    p["CURRENT_TIMESTAMP", :datetime].should == Sequel::CURRENT_TIMESTAMP
+    p["CURRENT_DATE", :datetime].should == Sequel::CURRENT_TIMESTAMP
+    p["now()", :datetime].should == Sequel::CURRENT_TIMESTAMP
+    p["getdate()", :datetime].should == Sequel::CURRENT_TIMESTAMP
     p["'2009-10-29T10:20:30-07:00'", :datetime].should == DateTime.parse('2009-10-29T10:20:30-07:00')
     p["'2009-10-29 10:20:30'", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
     p["'10:20:30'", :time].should == Time.parse('10:20:30')
     p["NaN", :float].should be_nil
 
-    db.meta_def(:database_type){:postgres}
+    db = Sequel.mock(:host=>'postgres')
     p["''::text", :string].should == ""
     p["'\\a''b'::character varying", :string].should == "\\a'b"
     p["'a'::bpchar", :string].should == "a"
@@ -2105,7 +2112,7 @@ describe "Database#column_schema_to_ruby_default" do
     p["'2009-10-29 10:20:30.241343'::timestamp without time zone", :datetime].should == DateTime.parse('2009-10-29 10:20:30.241343')
     p["'10:20:30'::time without time zone", :time].should == Time.parse('10:20:30')
 
-    db.meta_def(:database_type){:mysql}
+    db = Sequel.mock(:host=>'mysql')
     p["\\a'b", :string].should == "\\a'b"
     p["a", :string].should == "a"
     p["NULL", :string].should == "NULL"
@@ -2114,11 +2121,10 @@ describe "Database#column_schema_to_ruby_default" do
     p["2009-10-29", :date].should == Date.new(2009,10,29)
     p["2009-10-29 10:20:30", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
     p["10:20:30", :time].should == Time.parse('10:20:30')
-    p["CURRENT_DATE", :date].should be_nil
-    p["CURRENT_TIMESTAMP", :datetime].should be_nil
     p["a", :enum].should == "a"
+    p["a,b", :set].should == "a,b"
     
-    db.meta_def(:database_type){:mssql}
+    db = Sequel.mock(:host=>'mssql')
     p["(N'a')", :string].should == "a"
     p["((-12))", :integer].should == -12
     p["((12.1))", :float].should == 12.1

data/spec/core/dataset_spec.rb

@@ -241,16 +241,6 @@ describe "A simple dataset" do
       should match(/INSERT INTO test \(name, price\) VALUES \('wxyz', 342\)|INSERT INTO test \(price, name\) VALUES \(342, 'wxyz'\)/)
   end
   
-  specify "should format an insert statement with an object that respond_to? :values" do
-    v = Object.new
-    def v.values; {:a => 1}; end
-    
-    @dataset.insert_sql(v).should == "INSERT INTO test (a) VALUES (1)"
-    
-    def v.values; {}; end
-    @dataset.insert_sql(v).should == "INSERT INTO test DEFAULT VALUES"
-  end
-  
   specify "should format an insert statement with an arbitrary value" do
     @dataset.insert_sql(123).should == "INSERT INTO test VALUES (123)"
   end
@@ -338,7 +328,7 @@ end
 
 describe "Dataset#exists" do
   before do
-    @ds1 = Sequel::Dataset.new(nil).from(:test)
+    @ds1 = Sequel.mock[:test]
     @ds2 = @ds1.filter(Sequel.expr(:price) < 100)
     @ds3 = @ds1.filter(Sequel.expr(:price) > 50)
   end
@@ -358,7 +348,7 @@ end
 
 describe "Dataset#where" do
   before do
-    @dataset = Sequel::Dataset.new(nil).from(:test)
+    @dataset = Sequel.mock[:test]
     @d1 = @dataset.where(:region => 'Asia')
     @d2 = @dataset.where('region = ?', 'Asia')
     @d3 = @dataset.where("a = 1")
@@ -1836,6 +1826,25 @@ describe "Dataset#count" do
     @db.sqls.should == ['SELECT COUNT(*) AS count FROM test LIMIT 1']
   end
   
+  specify "should accept an argument" do
+    @dataset.count(:foo).should == 1
+    @db.sqls.should == ['SELECT COUNT(foo) AS count FROM test LIMIT 1']
+  end
+  
+  specify "should work with a nil argument" do
+    @dataset.count(nil).should == 1
+    @db.sqls.should == ['SELECT COUNT(NULL) AS count FROM test LIMIT 1']
+  end
+  
+  specify "should accept a virtual row block" do
+    @dataset.count{foo(bar)}.should == 1
+    @db.sqls.should == ['SELECT COUNT(foo(bar)) AS count FROM test LIMIT 1']
+  end
+  
+  specify "should raise an Error if given an argument and a block" do
+    proc{@dataset.count(:foo){foo(bar)}}.should raise_error(Sequel::Error)
+  end
+  
   specify "should include the where clause if it's there" do
     @dataset.filter(Sequel.expr(:abc) < 30).count.should == 1
     @db.sqls.should == ['SELECT COUNT(*) AS count FROM test WHERE (abc < 30) LIMIT 1']
@@ -2159,12 +2168,6 @@ describe "Dataset#join_table" do
       'RIGHT OUTER JOIN (SELECT * FROM attributes WHERE (name = \'blah\')) AS "t3" ON ("t3"."attribute_id" = "t2"."id")'
   end
 
-  specify "should support joining objects that respond to :table_name" do
-    ds = Object.new
-    def ds.table_name; :categories end
-    @d.join(ds, :item_id => :id).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."item_id" = "items"."id")'
-  end
-  
   specify "should support using an SQL String as the join condition" do
     @d.join(:categories, "c.item_id = items.id", :c).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" AS "c" ON (c.item_id = items.id)'
   end
@@ -2323,6 +2326,13 @@ describe "Dataset#insert_multiple" do
   specify "should return array of inserted ids" do
     @ds.insert_multiple(['aa', 5, 3, {:a => 2}]).should == [2, 3, 4, 5]
   end
+
+  specify "should work exactly like in metioned in the example" do
+    @ds.insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2 ; row }
+    sqls = @db.sqls
+    ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].should include(sqls[0])
+    ["INSERT INTO items (x, y) VALUES (2, 4)", "INSERT INTO items (y, x) VALUES (4, 2)"].should include(sqls[1])
+  end
 end
 
 describe "Dataset aggregate methods" do
@@ -3055,18 +3065,6 @@ describe "Dataset#insert_sql" do
   specify "should accept an array of columns and an LiteralString" do
     @ds.insert_sql([:a, :b, :c], Sequel.lit('VALUES (1, 2, 3)')).should == "INSERT INTO items (a, b, c) VALUES (1, 2, 3)"
   end
-  
-  specify "should accept an object that responds to values and returns a hash by using that hash as the columns and values" do
-    o = Object.new
-    def o.values; {:c=>'d'}; end
-    @ds.insert_sql(o).should == "INSERT INTO items (c) VALUES ('d')"
-  end
-  
-  specify "should accept an object that responds to values and returns something other than a hash by using the object itself as a single value" do
-    o = Date.civil(2000, 1, 1)
-    def o.values; self; end
-    @ds.insert_sql(o).should == "INSERT INTO items VALUES ('2000-01-01')"
-  end
 end
 
 describe "Dataset#inspect" do
@@ -3108,7 +3106,7 @@ end
 
 describe "Dataset#grep" do
   before do
-    @ds = Sequel::Dataset.new(nil).from(:posts)
+    @ds = Sequel.mock[:posts]
   end
   
   specify "should format a SQL filter correctly" do
@@ -3155,7 +3153,13 @@ describe "Dataset#grep" do
     @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE ((title ILIKE 'abc') AND (body ILIKE 'abc') AND (title ILIKE 'def') AND (body ILIKE 'def'))"
   end
 
-  specify "should support regexps though the database may not support it" do
+  specify "should not support regexps if the database doesn't supports it" do
+    proc{@ds.grep(:title, /ruby/).sql}.should raise_error(Sequel::InvalidOperation)
+    proc{@ds.grep(:title, [/^ruby/, 'ruby']).sql}.should raise_error(Sequel::InvalidOperation)
+  end
+
+  specify "should support regexps if the database supports it" do
+    def @ds.supports_regexp?; true end
     @ds.grep(:title, /ruby/).sql.should == "SELECT * FROM posts WHERE ((title ~ 'ruby'))"
     @ds.grep(:title, [/^ruby/, 'ruby']).sql.should == "SELECT * FROM posts WHERE ((title ~ '^ruby') OR (title LIKE 'ruby'))"
   end