sequel 2.11.0 → 2.12.0

data/spec/{sequel_core → core}/dataset_spec.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
 context "Dataset" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new("db")
   end
   
@@ -63,7 +63,7 @@ context "Dataset" do
 end
 
 context "Dataset" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new("db")
   end
   
@@ -74,14 +74,14 @@ context "Dataset" do
     @dataset.literal(:a).should == 'a'
   end
   
-  specify "should have upcase_identifiers= method which changes literalization of identifiers" do
+  deprec_specify "should have upcase_identifiers= method which changes literalization of identifiers" do
     @dataset.upcase_identifiers = true
     @dataset.literal(:a).should == 'A'
     @dataset.upcase_identifiers = false
     @dataset.literal(:a).should == 'a'
   end
 
-  specify "should have upcase_identifiers? method which returns whether identifiers are currently upcased" do
+  deprec_specify "should have upcase_identifiers? method which returns whether identifiers are currently upcased" do
     @dataset.upcase_identifiers = true
     @dataset.upcase_identifiers?.should == true
     @dataset.upcase_identifiers = false
@@ -109,18 +109,18 @@ context "Dataset" do
 end
 
 context "Dataset#clone" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:items)
   end
   
   specify "should create an exact copy of the dataset" do
-    @c = Class.new
-    @dataset.set_model(@c)
+    @dataset.row_proc = Proc.new{|r| r}
     @clone = @dataset.clone
 
     @clone.should_not === @dataset
     @clone.class.should == @dataset.class
-    @clone.model_classes.should == @dataset.model_classes
+    @clone.opts.should == @dataset.opts
+    @clone.row_proc.should == @dataset.row_proc
   end
   
   specify "should deep-copy the dataset opts" do
@@ -164,7 +164,7 @@ context "Dataset#clone" do
 end
 
 context "A simple dataset" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -225,7 +225,7 @@ context "A simple dataset" do
   end
 
   specify "should be able to return rows for arbitrary SQL" do
-    @dataset.select_sql(:sql => 'xxx yyy zzz').should ==
+    @dataset.clone(:sql => 'xxx yyy zzz').select_sql.should ==
       "xxx yyy zzz"
   end
 
@@ -241,16 +241,16 @@ context "A simple dataset" do
 end
 
 context "A dataset with multiple tables in its FROM clause" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:t1, :t2)
   end
 
   specify "should raise on #update_sql" do
-    proc {@dataset.update_sql(:a=>1)}.should raise_error(Sequel::Error::InvalidOperation)
+    proc {@dataset.update_sql(:a=>1)}.should raise_error(Sequel::InvalidOperation)
   end
 
   specify "should raise on #delete_sql" do
-    proc {@dataset.delete_sql}.should raise_error(Sequel::Error::InvalidOperation)
+    proc {@dataset.delete_sql}.should raise_error(Sequel::InvalidOperation)
   end
 
   specify "should generate a select query FROM all specified tables" do
@@ -259,7 +259,7 @@ context "A dataset with multiple tables in its FROM clause" do
 end
 
 context "Dataset#exists" do
-  setup do
+  before do
     @ds1 = Sequel::Dataset.new(nil).from(:test)
     @ds2 = @ds1.filter(:price.sql_number < 100)
     @ds3 = @ds1.filter(:price.sql_number > 50)
@@ -279,7 +279,7 @@ context "Dataset#exists" do
 end
 
 context "Dataset#where" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
     @d1 = @dataset.where(:region => 'Asia')
     @d2 = @dataset.where('region = ?', 'Asia')
@@ -444,6 +444,14 @@ context "Dataset#where" do
       "SELECT * FROM test WHERE (((name < 'b') AND (table.id = 1)) OR is_active(blah, xx, x.y_z))"
   end
 
+  specify "should instance_eval the block in the context of a VirtualRow if the block doesn't request an argument" do
+    x = nil
+    @dataset.filter{x = self; false}
+    x.should be_a_kind_of(Sequel::SQL::VirtualRow)
+    @dataset.filter{((name < 'b') & {table__id => 1}) | is_active(blah, xx, x__y_z)}.sql.should ==
+      "SELECT * FROM test WHERE (((name < 'b') AND (table.id = 1)) OR is_active(blah, xx, x.y_z))"
+  end
+
   specify "should raise an error if an invalid argument is used" do
     proc{@dataset.filter(1)}.should raise_error(Sequel::Error)
   end
@@ -455,7 +463,7 @@ context "Dataset#where" do
 end
 
 context "Dataset#or" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
     @d1 = @dataset.where(:x => 1)
   end
@@ -496,7 +504,7 @@ context "Dataset#or" do
 end
 
 context "Dataset#and" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
     @d1 = @dataset.where(:x => 1)
   end
@@ -536,7 +544,7 @@ context "Dataset#and" do
 end
 
 context "Dataset#exclude" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
 
@@ -578,7 +586,7 @@ context "Dataset#exclude" do
 end
 
 context "Dataset#invert" do
-  setup do
+  before do
     @d = Sequel::Dataset.new(nil).from(:test)
   end
 
@@ -596,7 +604,7 @@ context "Dataset#invert" do
 end
 
 context "Dataset#having" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
     @grouped = @dataset.group(:region).select(:region, :sum.sql_function(:population), :avg.sql_function(:gdp))
     @d1 = @grouped.having('sum(population) > 10')
@@ -605,7 +613,7 @@ context "Dataset#having" do
   end
 
   specify "should raise if the dataset is not grouped" do
-    proc {@dataset.having('avg(gdp) > 10')}.should raise_error(Sequel::Error::InvalidOperation)
+    proc {@dataset.having('avg(gdp) > 10')}.should raise_error(Sequel::InvalidOperation)
   end
 
   specify "should affect select statements" do
@@ -625,7 +633,7 @@ context "Dataset#having" do
 end
 
 context "a grouped dataset" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test).group(:type_id)
   end
 
@@ -650,7 +658,7 @@ context "a grouped dataset" do
 end
 
 context "Dataset#group_by" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test).group_by(:type_id)
   end
 
@@ -689,7 +697,7 @@ context "Dataset#as" do
 end
 
 context "Dataset#literal" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -754,10 +762,10 @@ context "Dataset#literal" do
     @dataset.literal(d).should == s
   end
   
-  specify "should not literalize expression strings" do
-    @dataset.literal('col1 + 2'.expr).should == 'col1 + 2'
+  specify "should not modify literal strings" do
+    @dataset.literal('col1 + 2'.lit).should == 'col1 + 2'
     
-    @dataset.update_sql(:a => 'a + 2'.expr).should == 
+    @dataset.update_sql(:a => 'a + 2'.lit).should == 
       'UPDATE test SET a = a + 2'
   end
 
@@ -774,7 +782,7 @@ context "Dataset#literal" do
 end
 
 context "Dataset#from" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil)
   end
 
@@ -837,7 +845,7 @@ context "Dataset#from" do
 end
 
 context "Dataset#select" do
-  setup do
+  before do
     @d = Sequel::Dataset.new(nil).from(:test)
   end
 
@@ -887,21 +895,21 @@ context "Dataset#select" do
 
   specify "should accept a block that yields a virtual row" do
     @d.select{|o| o.a}.sql.should == 'SELECT a FROM test'
-    @d.select{|o| o.a(1)}.sql.should == 'SELECT a(1) FROM test'
+    @d.select{a(1)}.sql.should == 'SELECT a(1) FROM test'
     @d.select{|o| o.a(1, 2)}.sql.should == 'SELECT a(1, 2) FROM test'
-    @d.select{|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT a, a(1, 2) FROM test'
+    @d.select{[a, a(1, 2)]}.sql.should == 'SELECT a, a(1, 2) FROM test'
   end
 
   specify "should merge regular arguments with argument returned from block" do
-    @d.select(:b){|o| o.a}.sql.should == 'SELECT b, a FROM test'
+    @d.select(:b){a}.sql.should == 'SELECT b, a FROM test'
     @d.select(:b, :c){|o| o.a(1)}.sql.should == 'SELECT b, c, a(1) FROM test'
-    @d.select(:b){|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT b, a, a(1, 2) FROM test'
+    @d.select(:b){[a, a(1, 2)]}.sql.should == 'SELECT b, a, a(1, 2) FROM test'
     @d.select(:b, :c){|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT b, c, a, a(1, 2) FROM test'
   end
 end
 
 context "Dataset#select_all" do
-  setup do
+  before do
     @d = Sequel::Dataset.new(nil).from(:test)
   end
 
@@ -915,7 +923,7 @@ context "Dataset#select_all" do
 end
 
 context "Dataset#select_more" do
-  setup do
+  before do
     @d = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -932,12 +940,12 @@ context "Dataset#select_more" do
 
   specify "should accept a block that yields a virtual row" do
     @d.select(:a).select_more{|o| o.b}.sql.should == 'SELECT a, b FROM test'
-    @d.select(:a.*).select_more(:b.*){|o| o.b(1)}.sql.should == 'SELECT a.*, b.*, b(1) FROM test'
+    @d.select(:a.*).select_more(:b.*){b(1)}.sql.should == 'SELECT a.*, b.*, b(1) FROM test'
   end
 end
 
 context "Dataset#order" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -973,21 +981,21 @@ context "Dataset#order" do
 
   specify "should accept a block that yields a virtual row" do
     @dataset.order{|o| o.a}.sql.should == 'SELECT * FROM test ORDER BY a'
-    @dataset.order{|o| o.a(1)}.sql.should == 'SELECT * FROM test ORDER BY a(1)'
+    @dataset.order{a(1)}.sql.should == 'SELECT * FROM test ORDER BY a(1)'
     @dataset.order{|o| o.a(1, 2)}.sql.should == 'SELECT * FROM test ORDER BY a(1, 2)'
-    @dataset.order{|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY a, a(1, 2)'
+    @dataset.order{[a, a(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY a, a(1, 2)'
   end
 
   specify "should merge regular arguments with argument returned from block" do
-    @dataset.order(:b){|o| o.a}.sql.should == 'SELECT * FROM test ORDER BY b, a'
+    @dataset.order(:b){a}.sql.should == 'SELECT * FROM test ORDER BY b, a'
     @dataset.order(:b, :c){|o| o.a(1)}.sql.should == 'SELECT * FROM test ORDER BY b, c, a(1)'
-    @dataset.order(:b){|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY b, a, a(1, 2)'
+    @dataset.order(:b){[a, a(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY b, a, a(1, 2)'
     @dataset.order(:b, :c){|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY b, c, a, a(1, 2)'
   end
 end
 
 context "Dataset#unfiltered" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -998,7 +1006,7 @@ context "Dataset#unfiltered" do
 end
 
 context "Dataset#unordered" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -1009,7 +1017,7 @@ context "Dataset#unordered" do
 end
 
 context "Dataset#with_sql" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -1017,14 +1025,13 @@ context "Dataset#with_sql" do
     @dataset.with_sql('SELECT 1 FROM test').sql.should == 'SELECT 1 FROM test'
   end
   
-  specify "should keep row_proc and transform" do
+  specify "should keep row_proc" do
     @dataset.with_sql('SELECT 1 FROM test').row_proc.should == @dataset.row_proc
-    @dataset.with_sql('SELECT 1 FROM test').instance_variable_get(:@transform).should == @dataset.instance_variable_get(:@transform)
   end
 end
 
 context "Dataset#order_by" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -1055,7 +1062,7 @@ context "Dataset#order_by" do
 end
 
 context "Dataset#order_more" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -1071,12 +1078,12 @@ context "Dataset#order_more" do
 
   specify "should accept a block that yields a virtual row" do
     @dataset.order(:a).order_more{|o| o.b}.sql.should == 'SELECT * FROM test ORDER BY a, b'
-    @dataset.order(:a, :b).order_more(:c, :d){|o| [o.e, o.f(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY a, b, c, d, e, f(1, 2)'
+    @dataset.order(:a, :b).order_more(:c, :d){[e, f(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY a, b, c, d, e, f(1, 2)'
   end
 end
 
 context "Dataset#reverse_order" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -1119,7 +1126,7 @@ context "Dataset#reverse_order" do
 end
 
 context "Dataset#limit" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -1158,24 +1165,20 @@ context "Dataset#limit" do
 end
 
 context "Dataset#naked" do
-  setup do
+  before do
     @d1 = Sequel::Dataset.new(nil, {1 => 2, 3 => 4})
-    @d2 = Sequel::Dataset.new(nil, {1 => 2, 3 => 4}).set_model(Object)
-  end
-  
-  specify "should return a clone with :naked option set" do
-    naked = @d1.naked
-    naked.opts[:naked].should be_true
+    @d2 = @d1.clone
+    @d2.row_proc = Proc.new{|r| r}
   end
   
-  specify "should remove any existing reference to a model class" do
+  specify "should remove any existing row_proc" do
     naked = @d2.naked
-    naked.opts[:models].should be_nil
+    naked.row_proc.should be_nil
   end
 end
 
 context "Dataset#qualified_column_name" do
-  setup do
+  before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
@@ -1206,7 +1209,7 @@ class DummyDataset < Sequel::Dataset
 end
 
 context "Dataset#map" do
-  setup do
+  before do
     @d = DummyDataset.new(nil).from(:items)
   end
   
@@ -1224,7 +1227,7 @@ context "Dataset#map" do
 end
 
 context "Dataset#to_hash" do
-  setup do
+  before do
     @d = DummyDataset.new(nil).from(:items)
   end
   
@@ -1239,34 +1242,33 @@ context "Dataset#to_hash" do
   end
 end
 
-context "Dataset#uniq" do
-  setup do
+context "Dataset#distinct" do
+  before do
     @db = MockDatabase.new
     @dataset = @db[:test].select(:name)
   end
   
   specify "should include DISTINCT clause in statement" do
-    @dataset.uniq.sql.should == 'SELECT DISTINCT name FROM test'
+    @dataset.distinct.sql.should == 'SELECT DISTINCT name FROM test'
   end
   
-  specify "should be aliased by Dataset#distinct" do
-    @dataset.distinct.sql.should == 'SELECT DISTINCT name FROM test'
+  deprec_specify "should be aliased by Dataset#uniq" do
+    @dataset.uniq.sql.should == 'SELECT DISTINCT name FROM test'
   end
   
   specify "should accept an expression list" do
-    @dataset.uniq(:a, :b).sql.should == 'SELECT DISTINCT ON (a, b) name FROM test'
-
-    @dataset.uniq(:stamp.cast_as(:integer), :node_id=>nil).sql.should == 'SELECT DISTINCT ON (CAST(stamp AS integer), (node_id IS NULL)) name FROM test'
+    @dataset.distinct(:a, :b).sql.should == 'SELECT DISTINCT ON (a, b) name FROM test'
+    @dataset.distinct(:stamp.cast(:integer), :node_id=>nil).sql.should == 'SELECT DISTINCT ON (CAST(stamp AS integer), (node_id IS NULL)) name FROM test'
   end
 
   specify "should do a subselect for count" do
-    @dataset.uniq.count
+    @dataset.distinct.count
     @db.sqls.should == ['SELECT COUNT(*) FROM (SELECT DISTINCT name FROM test) AS t1 LIMIT 1']
   end
 end
 
 context "Dataset#count" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def self.sql
         @@sql
@@ -1286,7 +1288,7 @@ context "Dataset#count" do
     @c.sql.should == 'SELECT COUNT(*) FROM test LIMIT 1'
   end
   
-  specify "should be aliased by #size" do
+  deprec_specify "should be aliased by #size" do
     @dataset.size.should == 1
   end
   
@@ -1332,7 +1334,7 @@ end
 
 
 context "Dataset#group_and_count" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def self.sql
         @@sql
@@ -1356,7 +1358,7 @@ context "Dataset#group_and_count" do
       "SELECT a, b, count(*) AS count FROM test GROUP BY a, b ORDER BY count"
   end
   
-  specify "should work within query block" do
+  deprec_specify "should work within query block" do
     @ds.query{group_and_count(:a, :b)}.sql.should == 
       "SELECT a, b, count(*) AS count FROM test GROUP BY a, b ORDER BY count"
   end
@@ -1382,7 +1384,7 @@ context "Dataset#empty?" do
 end
 
 context "Dataset#join_table" do
-  setup do
+  before do
     @d = MockDataset.new(nil).from(:items)
     @d.quote_identifiers = true
   end
@@ -1518,7 +1520,7 @@ context "Dataset#join_table" do
     ds.filter!(:active => true)
 
     @d.join_table(:left_outer, ds, :item_id => :id).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories WHERE (active = \'t\')) AS "t1" ON ("t1"."item_id" = "items"."id")'
+      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories WHERE (active IS TRUE)) AS "t1" ON ("t1"."item_id" = "items"."id")'
   end
   
   specify "should support joining datasets and aliasing the join" do
@@ -1647,7 +1649,7 @@ context "Dataset#join_table" do
 end
 
 context "Dataset#[]=" do
-  setup do
+  before do
     c = Class.new(Sequel::Dataset) do
       def last_sql
         @@last_sql
@@ -1668,7 +1670,7 @@ context "Dataset#[]=" do
 end
 
 context "Dataset#set" do
-  setup do
+  before do
     c = Class.new(Sequel::Dataset) do
       def last_sql
         @@last_sql
@@ -1690,7 +1692,7 @@ end
 
 
 context "Dataset#insert_multiple" do
-  setup do
+  before do
     c = Class.new(Sequel::Dataset) do
       attr_reader :inserts
       def insert(arg)
@@ -1715,7 +1717,7 @@ context "Dataset#insert_multiple" do
 end
 
 context "Dataset aggregate methods" do
-  setup do
+  before do
     c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql)
         yield({1 => sql})
@@ -1746,7 +1748,7 @@ context "Dataset aggregate methods" do
 end
 
 context "Dataset#range" do
-  setup do
+  before do
     c = Class.new(Sequel::Dataset) do
       @@sql = nil
       
@@ -1774,7 +1776,7 @@ context "Dataset#range" do
 end
 
 context "Dataset#interval" do
-  setup do
+  before do
     c = Class.new(Sequel::Dataset) do
       @@sql = nil
       
@@ -1802,10 +1804,10 @@ context "Dataset#interval" do
 end
 
 context "Dataset #first and #last" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
-      def each(opts = nil, &block)
-        s = select_sql(opts)
+      def each(&block)
+        s = select_sql
         x = [:a,1,:b,2,s]
         i = /LIMIT (\d+)/.match(s)[1].to_i.times{yield x}
       end
@@ -1865,7 +1867,7 @@ context "Dataset #first and #last" do
 end
 
 context "Dataset compound operations" do
-  setup do
+  before do
     @a = Sequel::Dataset.new(nil).from(:a).filter(:z => 1)
     @b = Sequel::Dataset.new(nil).from(:b).filter(:z => 2)
   end
@@ -1915,7 +1917,7 @@ context "Dataset compound operations" do
 end
 
 context "Dataset#[]" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       @@last_dataset = nil
       
@@ -1923,7 +1925,7 @@ context "Dataset#[]" do
         @@last_dataset
       end
 
-      def single_record(opts = nil)
+      def single_record
         @@last_dataset = opts ? clone(opts) : self
         {1 => 2, 3 => 4}
       end
@@ -1941,7 +1943,7 @@ context "Dataset#[]" do
 end
 
 context "Dataset#single_record" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql)
         yield sql
@@ -1959,11 +1961,11 @@ context "Dataset#single_record" do
     @d.single_record.should == 'SELECT * FROM test LIMIT 1'
   end
   
-  specify "should pass opts to each" do
+  deprec_specify "should pass opts to each" do
     @d.single_record(:order => [:name]).should == 'SELECT * FROM test ORDER BY name LIMIT 1'
   end
   
-  specify "should override the limit if passed as an option" do
+  deprec_specify "should override the limit if passed as an option" do
     @d.single_record(:limit => 3).should == 'SELECT * FROM test LIMIT 1'
   end
 
@@ -1973,7 +1975,7 @@ context "Dataset#single_record" do
 end
 
 context "Dataset#single_value" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql)
         yield({1 => sql})
@@ -1991,7 +1993,7 @@ context "Dataset#single_value" do
     @d.single_value.should == 'SELECT * FROM test LIMIT 1'
   end
   
-  specify "should pass opts to each" do
+  deprec_specify "should pass opts to each" do
     @d.single_value(:from => [:blah]).should == 'SELECT * FROM blah LIMIT 1'
   end
   
@@ -2006,7 +2008,7 @@ context "Dataset#single_value" do
 end
 
 context "Dataset#get" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       attr_reader :last_sql
       
@@ -2034,7 +2036,7 @@ context "Dataset#get" do
   
   specify "should accept a block that yields a virtual row" do
     @d.get{|o| o.x__b.as(:name)}.should == "SELECT x.b AS name FROM test LIMIT 1"
-    @d.get{|o| o.x(1).as(:name)}.should == "SELECT x(1) AS name FROM test LIMIT 1"
+    @d.get{x(1).as(:name)}.should == "SELECT x(1) AS name FROM test LIMIT 1"
   end
   
   specify "should raise an error if both a regular argument and block argument are used" do
@@ -2043,7 +2045,7 @@ context "Dataset#get" do
 end
 
 context "Dataset#set_row_proc" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql, &block)
         # yield a hash with kind as the 1 bit of a number
@@ -2070,7 +2072,7 @@ context "Dataset#set_row_proc" do
 end
 
 context "Dataset#set_model" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql, &block)
         # yield a hash with kind as the 1 bit of a number
@@ -2085,38 +2087,38 @@ context "Dataset#set_model" do
     end
   end
   
-  specify "should clear the models hash and restore the stock #each if nil is specified" do
+  deprec_specify "should clear the models hash and restore the stock #each if nil is specified" do
     @dataset.set_model(@m)
     @dataset.set_model(nil)
     @dataset.first.should == {:kind => 1}
     @dataset.model_classes.should be_nil
   end
   
-  specify "should clear the models hash and restore the stock #each if nothing is specified" do
+  deprec_specify "should clear the models hash and restore the stock #each if nothing is specified" do
     @dataset.set_model(@m)
     @dataset.set_model(nil)
     @dataset.first.should == {:kind => 1}
     @dataset.model_classes.should be_nil
   end
   
-  specify "should alter #each to provide model instances" do
+  deprec_specify "should alter #each to provide model instances" do
     @dataset.first.should == {:kind => 1}
     @dataset.set_model(@m)
     @dataset.first.should == @m.new({:kind => 1})
   end
   
-  specify "should set opts[:naked] to nil" do
+  deprec_specify "should set opts[:naked] to nil" do
     @dataset.opts[:naked] = true
     @dataset.set_model(@m)
     @dataset.opts[:naked].should be_nil
   end
   
-  specify "should send additional arguments to the models' initialize method" do
+  deprec_specify "should send additional arguments to the models' initialize method" do
     @dataset.set_model(@m, 7, 6, 5)
     @dataset.first.should == @m.new({:kind => 1}, 7, 6, 5)
   end
   
-  specify "should provide support for polymorphic model instantiation" do
+  deprec_specify "should provide support for polymorphic model instantiation" do
     @m1 = Class.new(@m)
     @m2 = Class.new(@m)
     @dataset.set_model(:kind, 0 => @m1, 1 => @m2)
@@ -2133,7 +2135,7 @@ context "Dataset#set_model" do
     @dataset.first.should == {:kind => 1}
   end
   
-  specify "should send additional arguments for polymorphic models as well" do
+  deprec_specify "should send additional arguments for polymorphic models as well" do
     @m1 = Class.new(@m)
     @m2 = Class.new(@m)
     @dataset.set_model(:kind, {0 => @m1, 1 => @m2}, :hey => :wow)
@@ -2144,7 +2146,7 @@ context "Dataset#set_model" do
     all[3].class.should == @m1; all[3].args.should == [{:hey => :wow}]
   end
   
-  specify "should raise for invalid parameters" do
+  deprec_specify "should raise for invalid parameters" do
     proc {@dataset.set_model('kind')}.should raise_error(ArgumentError)
     proc {@dataset.set_model(0)}.should raise_error(ArgumentError)
     proc {@dataset.set_model(:kind)}.should raise_error(ArgumentError) # no hash given
@@ -2152,7 +2154,7 @@ context "Dataset#set_model" do
 end
 
 context "Dataset#model_classes" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       # # We don't need that for now
       # def fetch_rows(sql, &block)
@@ -2167,16 +2169,16 @@ context "Dataset#model_classes" do
     end
   end
   
-  specify "should return nil for a naked dataset" do
+  deprec_specify "should return nil for a naked dataset" do
     @dataset.model_classes.should == nil
   end
   
-  specify "should return a {nil => model_class} hash for a model dataset" do
+  deprec_specify "should return a {nil => model_class} hash for a model dataset" do
     @dataset.set_model(@m)
     @dataset.model_classes.should == {nil => @m}
   end
   
-  specify "should return the polymorphic hash for a polymorphic model dataset" do
+  deprec_specify "should return the polymorphic hash for a polymorphic model dataset" do
     @m1 = Class.new(@m)
     @m2 = Class.new(@m)
     @dataset.set_model(:key, 0 => @m1, 1 => @m2)
@@ -2185,7 +2187,7 @@ context "Dataset#model_classes" do
 end
 
 context "Dataset#polymorphic_key" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       # # We don't need this for now
       # def fetch_rows(sql, &block)
@@ -2200,18 +2202,18 @@ context "Dataset#polymorphic_key" do
     end
   end
   
-  specify "should return nil for a naked dataset" do
+  deprec_specify "should return nil for a naked dataset" do
     @dataset.polymorphic_key.should be_nil
   end
   
-  specify "should return the polymorphic key" do
+  deprec_specify "should return the polymorphic key" do
     @dataset.set_model(:id, nil => @m)
     @dataset.polymorphic_key.should == :id
   end
 end
 
 context "A model dataset" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql, &block)
         (1..10).each(&block)
@@ -2223,17 +2225,17 @@ context "A model dataset" do
       def initialize(c); @c = c; end
       def ==(o); @c == o.c; end
     end
-    @dataset.set_model(@m)
+    @dataset.row_proc = Proc.new{|r| @m.new(r)}
   end
   
-  specify "should supply naked records if the naked option is specified" do
+  deprec_specify "should supply naked records if the naked option is specified" do
     @dataset.each {|r| r.class.should == @m}
-    @dataset.each(:naked => true) {|r| r.class.should == Fixnum}
+    @dataset.naked.each(:naked => true) {|r| r.class.should == Fixnum}
   end
 end
 
 context "A polymorphic model dataset" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql, &block)
         (1..10).each {|i| block.call(:bit => i[0])}
@@ -2247,7 +2249,7 @@ context "A polymorphic model dataset" do
     end
   end
   
-  specify "should use a nil key in the polymorphic hash to specify the default model class" do
+  deprec_specify "should use a nil key in the polymorphic hash to specify the default model class" do
     @m2 = Class.new(@m)
     @dataset.set_model(:bit, nil => @m, 1 => @m2)
     all = @dataset.all
@@ -2258,20 +2260,20 @@ context "A polymorphic model dataset" do
     #...
   end
   
-  specify "should raise Sequel::Error if no suitable class is found in the polymorphic hash" do
+  deprec_specify "should raise Sequel::Error if no suitable class is found in the polymorphic hash" do
     @m2 = Class.new(@m)
     @dataset.set_model(:bit, 1 => @m2)
     proc {@dataset.all}.should raise_error(Sequel::Error)
   end
 
-  specify "should supply naked records if the naked option is specified" do
+  deprec_specify "should supply naked records if the naked option is specified" do
     @dataset.set_model(:bit, nil => @m)
     @dataset.each(:naked => true) {|r| r.class.should == Hash}
   end
 end
 
 context "A dataset with associated model class(es)" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql, &block)
         block.call({:x => 1, :y => 2})
@@ -2290,14 +2292,14 @@ context "A dataset with associated model class(es)" do
     @m3 = Class.new(@m2)
   end
 
-  specify "should instantiate an instance by passing the record hash as argument" do
+  deprec_specify "should instantiate an instance by passing the record hash as argument" do
     @dataset.set_model(@m1)
     o = @dataset.first
     o.class.should == @m1
     o.v.should == {:x => 1, :y => 2}
   end
   
-  specify "should use the .load constructor if available" do
+  deprec_specify "should use the .load constructor if available" do
     @dataset.set_model(@m2)
     o = @dataset.first
     o.class.should == @m2
@@ -2305,7 +2307,7 @@ context "A dataset with associated model class(es)" do
     o.vv.should == {:x => 1, :y => 2}
   end
   
-  specify "should use the .load constructor also for polymorphic datasets" do
+  deprec_specify "should use the .load constructor also for polymorphic datasets" do
     @dataset.set_model(:y, 1 => @m2, 2 => @m3)
     o = @dataset.first
     o.class.should == @m3
@@ -2315,7 +2317,7 @@ context "A dataset with associated model class(es)" do
 end
 
 context "Dataset#<<" do
-  setup do
+  before do
     @d = Sequel::Dataset.new(nil)
     @d.meta_def(:insert) do |*args|
       1234567890
@@ -2328,75 +2330,75 @@ context "Dataset#<<" do
 end
 
 context "A paginated dataset" do
-  setup do
+  before do
     @d = Sequel::Dataset.new(nil)
     @d.meta_def(:count) {153}
     
-    @paginated = @d.paginate(1, 20)
+    deprec{@paginated = @d.paginate(1, 20)}
   end
   
-  specify "should raise an error if the dataset already has a limit" do
+ deprec_specify "should raise an error if the dataset already has a limit" do
     proc{@d.limit(10).paginate(1,10)}.should raise_error(Sequel::Error)
     proc{@paginated.paginate(2,20)}.should raise_error(Sequel::Error)
   end
   
-  specify "should set the limit and offset options correctly" do
+  deprec_specify "should set the limit and offset options correctly" do
     @paginated.opts[:limit].should == 20
     @paginated.opts[:offset].should == 0
   end
   
-  specify "should set the page count correctly" do
+  deprec_specify "should set the page count correctly" do
     @paginated.page_count.should == 8
     @d.paginate(1, 50).page_count.should == 4
   end
   
-  specify "should set the current page number correctly" do
+  deprec_specify "should set the current page number correctly" do
     @paginated.current_page.should == 1
     @d.paginate(3, 50).current_page.should == 3
   end
   
-  specify "should return the next page number or nil if we're on the last" do
+  deprec_specify "should return the next page number or nil if we're on the last" do
     @paginated.next_page.should == 2
     @d.paginate(4, 50).next_page.should be_nil
   end
   
-  specify "should return the previous page number or nil if we're on the last" do
+  deprec_specify "should return the previous page number or nil if we're on the last" do
     @paginated.prev_page.should be_nil
     @d.paginate(4, 50).prev_page.should == 3
   end
   
-  specify "should return the page range" do
+  deprec_specify "should return the page range" do
     @paginated.page_range.should == (1..8)
     @d.paginate(4, 50).page_range.should == (1..4)
   end
   
-  specify "should return the record range for the current page" do
+  deprec_specify "should return the record range for the current page" do
     @paginated.current_page_record_range.should == (1..20)
     @d.paginate(4, 50).current_page_record_range.should == (151..153)
     @d.paginate(5, 50).current_page_record_range.should == (0..0)
   end
 
-  specify "should return the record count for the current page" do
+  deprec_specify "should return the record count for the current page" do
     @paginated.current_page_record_count.should == 20
     @d.paginate(3, 50).current_page_record_count.should == 50
     @d.paginate(4, 50).current_page_record_count.should == 3
     @d.paginate(5, 50).current_page_record_count.should == 0
   end
 
-  specify "should know if current page is last page" do
+  deprec_specify "should know if current page is last page" do
     @paginated.last_page?.should be_false
     @d.paginate(2, 20).last_page?.should be_false
     @d.paginate(5, 30).last_page?.should be_false
     @d.paginate(6, 30).last_page?.should be_true
   end
 
-  specify "should know if current page is first page" do
+  deprec_specify "should know if current page is first page" do
     @paginated.first_page?.should be_true
     @d.paginate(1, 20).first_page?.should be_true
     @d.paginate(2, 20).first_page?.should be_false
   end
 
-  specify "should work with fixed sql" do
+  deprec_specify "should work with fixed sql" do
     ds = @d.clone(:sql => 'select * from blah')
     ds.meta_def(:count) {150}
     ds.paginate(2, 50).sql.should == 'SELECT * FROM (select * from blah) AS t1 LIMIT 50 OFFSET 50'
@@ -2404,16 +2406,16 @@ context "A paginated dataset" do
 end
 
 context "Dataset#each_page" do
-  setup do
+  before do
     @d = Sequel::Dataset.new(nil).from(:items)
     @d.meta_def(:count) {153}
   end
   
-  specify "should raise an error if the dataset already has a limit" do
+  deprec_specify "should raise an error if the dataset already has a limit" do
     proc{@d.limit(10).each_page(10){}}.should raise_error(Sequel::Error)
   end
   
-  specify "should iterate over each page in the resultset as a paginated dataset" do
+  deprec_specify "should iterate over each page in the resultset as a paginated dataset" do
     a = []
     @d.each_page(50) {|p| a << p}
     a.map {|p| p.sql}.should == [
@@ -2426,11 +2428,11 @@ context "Dataset#each_page" do
 end
 
 context "Dataset#columns" do
-  setup do
+  before do
     @dataset = DummyDataset.new(nil).from(:items)
     @dataset.meta_def(:columns=) {|c| @columns = c}
     i = 'a' 
-    @dataset.meta_def(:each) {|o| @columns = select_sql(o||@opts) + i; i = i.next}
+    @dataset.meta_def(:each){@columns = select_sql + i; i = i.next}
   end
   
   specify "should return the value of @columns if @columns is not nil" do
@@ -2453,10 +2455,10 @@ context "Dataset#columns" do
 end
 
 context "Dataset#columns!" do
-  setup do
+  before do
     @dataset = DummyDataset.new(nil).from(:items)
     i = 'a' 
-    @dataset.meta_def(:each) {|o| @columns = select_sql(o||@opts) + i; i = i.next}
+    @dataset.meta_def(:each){@columns = select_sql + i; i = i.next}
   end
   
   specify "should always attempt to get a record and return @columns" do
@@ -2470,25 +2472,25 @@ end
 require 'stringio'
 
 context "Dataset#print" do
-  setup do
+  before do
     @output = StringIO.new
     @orig_stdout = $stdout
     $stdout = @output
     @dataset = DummyDataset.new(nil).from(:items)
   end
   
-  teardown do
+  after do
     $stdout = @orig_stdout
   end
   
-  specify "should print out a table with the values" do
+  deprec_specify "should print out a table with the values" do
     @dataset.print(:a, :b)
     @output.rewind
     @output.read.should == \
       "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n"
   end
 
-  specify "should default to the dataset's columns" do
+  deprec_specify "should default to the dataset's columns" do
     @dataset.meta_def(:columns) {[:a, :b]}
     @dataset.print
     @output.rewind
@@ -2497,8 +2499,8 @@ context "Dataset#print" do
   end
 end
 
-context "Dataset#multi_insert" do
-  setup do
+context "Dataset#import" do
+  before do
     @dbc = Class.new do
       attr_reader :sqls
       
@@ -2508,7 +2510,7 @@ context "Dataset#multi_insert" do
       end
       alias execute_dui execute
       
-      def transaction
+      def transaction(opts={})
         @sqls ||= []
         @sqls << 'BEGIN'
         yield
@@ -2522,8 +2524,8 @@ context "Dataset#multi_insert" do
     @list = [{:name => 'abc'}, {:name => 'def'}, {:name => 'ghi'}]
   end
   
-  specify "should join all inserts into a single SQL string" do
-    @ds.multi_insert(@list)
+  deprec_specify "should issue multiple inserts inside a transaction" do
+    @ds.import(@list)
     @db.sqls.should == [
       'BEGIN',
       "INSERT INTO items (name) VALUES ('abc')",
@@ -2533,8 +2535,41 @@ context "Dataset#multi_insert" do
     ]
   end
   
-  specify "should accept the :commit_every option for committing every x records" do
-    @ds.multi_insert(@list, :commit_every => 2)
+  deprec_specify "should handle different formats for tables" do
+    @ds = @ds.from(:sch__tab)
+    @ds.import(@list)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO sch.tab (name) VALUES ('abc')",
+      "INSERT INTO sch.tab (name) VALUES ('def')",
+      "INSERT INTO sch.tab (name) VALUES ('ghi')",
+      'COMMIT'
+    ]
+    @db.sqls.clear
+
+    @ds = @ds.from(:tab.qualify(:sch))
+    @ds.import(@list)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO sch.tab (name) VALUES ('abc')",
+      "INSERT INTO sch.tab (name) VALUES ('def')",
+      "INSERT INTO sch.tab (name) VALUES ('ghi')",
+      'COMMIT'
+    ]
+    @db.sqls.clear
+    @ds = @ds.from(:sch__tab.identifier)
+    @ds.import(@list)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO sch__tab (name) VALUES ('abc')",
+      "INSERT INTO sch__tab (name) VALUES ('def')",
+      "INSERT INTO sch__tab (name) VALUES ('ghi')",
+      'COMMIT'
+    ]
+  end
+  
+  deprec_specify "should accept the :commit_every option for committing every x records" do
+    @ds.import(@list, :commit_every => 2)
     @db.sqls.should == [
       'BEGIN',
       "INSERT INTO items (name) VALUES ('abc')",
@@ -2546,8 +2581,8 @@ context "Dataset#multi_insert" do
     ]
   end
 
-  specify "should accept the :slice option for committing every x records" do
-    @ds.multi_insert(@list, :slice => 2)
+  deprec_specify "should accept the :slice option for committing every x records" do
+    @ds.import(@list, :slice => 2)
     @db.sqls.should == [
       'BEGIN',
       "INSERT INTO items (name) VALUES ('abc')",
@@ -2560,18 +2595,17 @@ context "Dataset#multi_insert" do
   end
   
   specify "should accept string keys as column names" do
-    @ds.multi_insert([{'x'=>1, 'y'=>2}, {'x'=>3, 'y'=>4}])
-    @ds.multi_insert(['x', 'y'], [[1, 2], [3, 4]])
+    @ds.import(['x', 'y'], [[1, 2], [3, 4]])
     @db.sqls.should == [
       'BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
       "INSERT INTO items (x, y) VALUES (3, 4)",
       'COMMIT'
-    ] * 2
+    ]
   end
 
   specify "should accept a columns array and a values array" do
-    @ds.multi_insert([:x, :y], [[1, 2], [3, 4]])
+    @ds.import([:x, :y], [[1, 2], [3, 4]])
     @db.sqls.should == [
       'BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
@@ -2583,16 +2617,16 @@ context "Dataset#multi_insert" do
   specify "should accept a columns array and a dataset" do
     @ds2 = Sequel::Dataset.new(@db).from(:cats).filter(:purr => true).select(:a, :b)
     
-    @ds.multi_insert([:x, :y], @ds2)
+    @ds.import([:x, :y], @ds2)
     @db.sqls.should == [
       'BEGIN',
-      "INSERT INTO items (x, y) VALUES (SELECT a, b FROM cats WHERE (purr = 't'))",
+      "INSERT INTO items (x, y) VALUES (SELECT a, b FROM cats WHERE (purr IS TRUE))",
       'COMMIT'
     ]
   end
 
   specify "should accept a columns array and a values array with slice option" do
-    @ds.multi_insert([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
+    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
     @db.sqls.should == [
       'BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
@@ -2604,35 +2638,151 @@ context "Dataset#multi_insert" do
     ]
   end
   
-  specify "should be aliased by #import" do
-    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
+  deprec_specify "should not do anything if no columns or values are given" do
+    @ds.import
+    @db.sqls.should be_nil
+    
+    @ds.import([])
+    @db.sqls.should be_nil
+    
+    @ds.import([], [])
+    @db.sqls.should be_nil
+
+    @ds.import([{}, {}])
+    @db.sqls.should be_nil
+    
+    @ds.import([:a, :b], [])
+    @db.sqls.should be_nil
+  end
+end
+
+context "Dataset#multi_insert" do
+  before do
+    @dbc = Class.new do
+      attr_reader :sqls
+      
+      def execute(sql, opts={})
+        @sqls ||= []
+        @sqls << sql
+      end
+      alias execute_dui execute
+      
+      def transaction(opts={})
+        @sqls ||= []
+        @sqls << 'BEGIN'
+        yield
+        @sqls << 'COMMIT'
+      end
+    end
+    @db = @dbc.new
+    
+    @ds = Sequel::Dataset.new(@db).from(:items)
+    
+    @list = [{:name => 'abc'}, {:name => 'def'}, {:name => 'ghi'}]
+  end
+  
+  specify "should issue multiple insert statements inside a transaction" do
+    @ds.multi_insert(@list)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (name) VALUES ('abc')",
+      "INSERT INTO items (name) VALUES ('def')",
+      "INSERT INTO items (name) VALUES ('ghi')",
+      'COMMIT'
+    ]
+  end
+  
+  specify "should handle different formats for tables" do
+    @ds = @ds.from(:sch__tab)
+    @ds.multi_insert(@list)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO sch.tab (name) VALUES ('abc')",
+      "INSERT INTO sch.tab (name) VALUES ('def')",
+      "INSERT INTO sch.tab (name) VALUES ('ghi')",
+      'COMMIT'
+    ]
+    @db.sqls.clear
+
+    @ds = @ds.from(:tab.qualify(:sch))
+    @ds.multi_insert(@list)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO sch.tab (name) VALUES ('abc')",
+      "INSERT INTO sch.tab (name) VALUES ('def')",
+      "INSERT INTO sch.tab (name) VALUES ('ghi')",
+      'COMMIT'
+    ]
+    @db.sqls.clear
+    @ds = @ds.from(:sch__tab.identifier)
+    @ds.multi_insert(@list)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO sch__tab (name) VALUES ('abc')",
+      "INSERT INTO sch__tab (name) VALUES ('def')",
+      "INSERT INTO sch__tab (name) VALUES ('ghi')",
+      'COMMIT'
+    ]
+  end
+  
+  specify "should accept the :commit_every option for committing every x records" do
+    @ds.multi_insert(@list, :commit_every => 2)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (name) VALUES ('abc')",
+      "INSERT INTO items (name) VALUES ('def')",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (name) VALUES ('ghi')",
+      'COMMIT'
+    ]
+  end
+
+  specify "should accept the :slice option for committing every x records" do
+    @ds.multi_insert(@list, :slice => 2)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (name) VALUES ('abc')",
+      "INSERT INTO items (name) VALUES ('def')",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (name) VALUES ('ghi')",
+      'COMMIT'
+    ]
+  end
+  
+  specify "should accept string keys as column names" do
+    @ds.multi_insert([{'x'=>1, 'y'=>2}, {'x'=>3, 'y'=>4}])
     @db.sqls.should == [
       'BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
       "INSERT INTO items (x, y) VALUES (3, 4)",
-      'COMMIT',
+      'COMMIT'
+    ]
+  end
+
+  deprec_specify "should accept a columns array and a values array" do
+    @ds.multi_insert([:x, :y], [[1, 2], [3, 4]])
+    @db.sqls.should == [
       'BEGIN',
-      "INSERT INTO items (x, y) VALUES (5, 6)",
+      "INSERT INTO items (x, y) VALUES (1, 2)",
+      "INSERT INTO items (x, y) VALUES (3, 4)",
       'COMMIT'
     ]
   end
 
-  specify "should not do anything if no columns or values are given" do
-    @ds.multi_insert
-    @db.sqls.should be_nil
-    
-    @ds.multi_insert([])
-    @db.sqls.should be_nil
+  deprec_specify "should accept a columns array and a dataset" do
+    @ds2 = Sequel::Dataset.new(@db).from(:cats).filter(:purr => true).select(:a, :b)
     
-    @ds.multi_insert([], [])
-    @db.sqls.should be_nil
+    @ds.multi_insert([:x, :y], @ds2)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (SELECT a, b FROM cats WHERE (purr IS TRUE))",
+      'COMMIT'
+    ]
+  end
 
-    @ds.multi_insert([{}, {}])
-    @db.sqls.should be_nil
-    
-    @ds.multi_insert([:a, :b], [])
-    @db.sqls.should be_nil
-    
+  deprec_specify "should accept a columns array and a values array with slice option" do
     @ds.multi_insert([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
     @db.sqls.should == [
       'BEGIN',
@@ -2645,20 +2795,24 @@ context "Dataset#multi_insert" do
     ]
   end
   
+  deprec_specify "should not do anything if no hashes are provided" do
+    @ds.multi_insert
+    @db.sqls.should be_nil
+  end
 end
 
 context "Dataset#query" do
-  setup do
+  before do
     @d = Sequel::Dataset.new(nil)
   end
   
-  specify "should support #from" do
+  deprec_specify "should support #from" do
     q = @d.query {from :xxx}
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM xxx"
   end
   
-  specify "should support #select" do
+  deprec_specify "should support #select" do
     q = @d.query do
       select :a, :b___mongo
       from :yyy
@@ -2667,7 +2821,7 @@ context "Dataset#query" do
     q.sql.should == "SELECT a, b AS mongo FROM yyy"
   end
   
-  specify "should support #where" do
+  deprec_specify "should support #where" do
     q = @d.query do
       from :zzz
       where(:x + 2 > :y + 3)
@@ -2688,7 +2842,7 @@ context "Dataset#query" do
     q.sql.should == "SELECT * FROM zzz WHERE (x = 33)"
   end
   
-  specify "should support #group_by and #having" do
+  deprec_specify "should support #group_by and #having" do
     q = @d.query do
       from :abc
       group_by :id
@@ -2698,7 +2852,7 @@ context "Dataset#query" do
     q.sql.should == "SELECT * FROM abc GROUP BY id HAVING (x >= 2)"
   end
   
-  specify "should support #order, #order_by" do
+  deprec_specify "should support #order, #order_by" do
     q = @d.query do
       from :xyz
       order_by :stamp
@@ -2707,11 +2861,11 @@ context "Dataset#query" do
     q.sql.should == "SELECT * FROM xyz ORDER BY stamp"
   end
   
-  specify "should raise on non-chainable method calls" do
+  deprec_specify "should raise on non-chainable method calls" do
     proc {@d.query {first_source}}.should raise_error(Sequel::Error)
   end
   
-  specify "should raise on each, insert, update, delete" do
+  deprec_specify "should raise on each, insert, update, delete" do
     proc {@d.query {each}}.should raise_error(Sequel::Error)
     proc {@d.query {insert(:x => 1)}}.should raise_error(Sequel::Error)
     proc {@d.query {update(:x => 1)}}.should raise_error(Sequel::Error)
@@ -2720,7 +2874,7 @@ context "Dataset#query" do
 end
 
 context "Dataset" do
-  setup do
+  before do
     @d = Sequel::Dataset.new(nil).from(:x)
   end
 
@@ -2767,7 +2921,7 @@ context "Dataset" do
 end
 
 context "Dataset#transform" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       attr_accessor :raw
       attr_accessor :sql
@@ -2786,20 +2940,22 @@ context "Dataset#transform" do
     end
 
     @ds = @c.new(nil).from(:items)
-    @ds.transform(:x => [
-      proc {|v| Marshal.load(v)},
-      proc {|v| Marshal.dump(v)}
-    ])
+    deprec do
+      @ds.transform(:x => [
+        proc {|v| Marshal.load(v)},
+        proc {|v| Marshal.dump(v)}
+      ])
+    end
   end
   
-  specify "should change the dataset to transform values loaded from the database" do
+  deprec_specify "should change the dataset to transform values loaded from the database" do
     @ds.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'}
     @ds.first.should == {:x => [1, 2, 3], :y => 'hello'}
     @ds.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'}
     @ds.all.should == [{:x => [1, 2, 3], :y => 'hello'}]
   end
   
-  specify "should change the dataset to transform values saved to the database" do
+  deprec_specify "should change the dataset to transform values saved to the database" do
     @ds.insert(:x => :toast)
     @ds.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}')"
 
@@ -2810,7 +2966,7 @@ context "Dataset#transform" do
     @ds.sql.should == "UPDATE items SET x = '#{Marshal.dump(['dream'])}'"
   end
   
-  specify "should be transferred to cloned datasets" do
+  deprec_specify "should be transferred to cloned datasets" do
     @ds2 = @ds.filter(:a => 1)
 
     @ds2.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'}
@@ -2820,18 +2976,18 @@ context "Dataset#transform" do
     @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}')"
   end
   
-  specify "should work correctly together with set_row_proc" do
+  deprec_specify "should work correctly together with set_row_proc" do
     @ds.row_proc = proc{|r| r[:z] = r[:x] * 2; r}
     @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'}
     @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"}
 
     f = nil
     @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'}
-    @ds.each(:naked => true) {|r| f = r}
+    @ds.naked.each{|r| f = r}
     f.should == {:x => "wow", :y => 'hello'}
   end
   
-  specify "should leave the supplied values intact" do
+  deprec_specify "should leave the supplied values intact" do
     h = {:x => :toast}
     @ds.insert(h)
     h.should == {:x => :toast}
@@ -2839,7 +2995,7 @@ context "Dataset#transform" do
 end
 
 context "Dataset#transform" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       attr_accessor :raw
       attr_accessor :sql
@@ -2860,7 +3016,7 @@ context "Dataset#transform" do
     @ds = @c.new(nil).from(:items)
   end
   
-  specify "should raise Sequel::Error for invalid transformations" do
+  deprec_specify "should raise Sequel::Error for invalid transformations" do
     proc {@ds.transform(:x => 'mau')}.should raise_error(Sequel::Error::InvalidTransform)
     proc {@ds.transform(:x => :mau)}.should raise_error(Sequel::Error::InvalidTransform)
     proc {@ds.transform(:x => [])}.should raise_error(Sequel::Error::InvalidTransform)
@@ -2868,7 +3024,7 @@ context "Dataset#transform" do
     proc {@ds.transform(:x => [proc {|v|}, proc {|v|}])}.should_not raise_error(Sequel::Error::InvalidTransform)
   end
   
-  specify "should support stock YAML transformation" do
+  deprec_specify "should support stock YAML transformation" do
     @ds.transform(:x => :yaml)
 
     @ds.raw = {:x => [1, 2, 3].to_yaml, :y => 'hello'}
@@ -2892,11 +3048,11 @@ context "Dataset#transform" do
     @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"}
     f = nil
     @ds.raw = {:x => "wow".to_yaml, :y => 'hello'}
-    @ds.each(:naked => true) {|r| f = r}
+    @ds.naked.each{|r| f = r}
     f.should == {:x => "wow", :y => 'hello'}
   end
   
-  specify "should support stock Marshal transformation with Base64 encoding" do
+  deprec_specify "should support stock Marshal transformation with Base64 encoding" do
     @ds.transform(:x => :marshal)
 
     @ds.raw = {:x => [Marshal.dump([1, 2, 3])].pack('m'), :y => 'hello'}
@@ -2920,29 +3076,29 @@ context "Dataset#transform" do
     @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"}
     f = nil
     @ds.raw = {:x => [Marshal.dump("wow")].pack('m'), :y => 'hello'}
-    @ds.each(:naked => true) {|r| f = r}
+    @ds.naked.each{|r| f = r}
     f.should == {:x => "wow", :y => 'hello'}
   end
   
-  specify "should support loading of Marshalled values without Base64 encoding" do
+  deprec_specify "should support loading of Marshalled values without Base64 encoding" do
     @ds.transform(:x => :marshal)
 
     @ds.raw = {:x => Marshal.dump([1,2,3]), :y => nil}
     @ds.first.should == {:x => [1,2,3], :y => nil}
   end
   
-  specify "should return self" do
+  deprec_specify "should return self" do
     @ds.transform(:x => :marshal).should be(@ds)
   end
 end
 
 context "A dataset with a transform" do
-  setup do
+  before do
     @ds = Sequel::Dataset.new(nil).from(:items)
-    @ds.transform(:x => :marshal)
+    deprec{@ds.transform(:x => :marshal)}
   end
   
-  specify "should automatically transform hash filters" do
+  deprec_specify "should automatically transform hash filters" do
     @ds.filter(:y => 2).sql.should == 'SELECT * FROM items WHERE (y = 2)'
     
     @ds.filter(:x => 2).sql.should == "SELECT * FROM items WHERE (x = '#{[Marshal.dump(2)].pack('m')}')"
@@ -2950,7 +3106,7 @@ context "A dataset with a transform" do
 end
 
 context "Dataset#to_csv" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       attr_accessor :data
       attr_accessor :columns
@@ -2982,7 +3138,7 @@ context "Dataset#to_csv" do
 end
 
 context "Dataset#create_view" do
-  setup do
+  before do
     @dbc = Class.new(Sequel::Database) do
       attr_reader :sqls
       
@@ -2996,14 +3152,14 @@ context "Dataset#create_view" do
     @ds = @db[:items].order(:abc).filter(:category => 'ruby')
   end
   
-  specify "should create a view with the dataset's sql" do
+  deprec_specify "should create a view with the dataset's sql" do
     @ds.create_view(:xyz)
     @db.sqls.should == ["CREATE VIEW xyz AS #{@ds.sql}"]
   end
 end
 
 context "Dataset#create_or_replace_view" do
-  setup do
+  before do
     @dbc = Class.new(Sequel::Database) do
       attr_reader :sqls
       
@@ -3017,14 +3173,14 @@ context "Dataset#create_or_replace_view" do
     @ds = @db[:items].order(:abc).filter(:category => 'ruby')
   end
   
-  specify "should create a view with the dataset's sql" do
+  deprec_specify "should create a view with the dataset's sql" do
     @ds.create_or_replace_view(:xyz)
     @db.sqls.should == ["CREATE OR REPLACE VIEW xyz AS #{@ds.sql}"]
   end
 end
 
 context "Dataset#update_sql" do
-  setup do
+  before do
     @ds = Sequel::Dataset.new(nil).from(:items)
   end
   
@@ -3037,12 +3193,12 @@ context "Dataset#update_sql" do
   end
 
   specify "should accept array subscript references" do
-    @ds.update_sql((:day|1) => 'd').should == "UPDATE items SET day[1] = 'd'"
+    @ds.update_sql((:day.sql_subscript(1)) => 'd').should == "UPDATE items SET day[1] = 'd'"
   end
 end
 
 context "Dataset#insert_sql" do
-  setup do
+  before do
     @ds = Sequel::Dataset.new(nil).from(:items)
   end
   
@@ -3055,7 +3211,7 @@ context "Dataset#insert_sql" do
   end
 
   specify "should accept array subscript references" do
-    @ds.insert_sql((:day|1) => 'd').should == "INSERT INTO items (day[1]) VALUES ('d')"
+    @ds.insert_sql((:day.sql_subscript(1)) => 'd').should == "INSERT INTO items (day[1]) VALUES ('d')"
   end
 end
 
@@ -3082,7 +3238,7 @@ class DummyMummyDatabase < Sequel::Database
 end
 
 context "Dataset#table_exists?" do
-  setup do
+  before do
     @db = DummyMummyDatabase.new
     @db.instance_variable_set(:@schemas, {:a=>[]})
     @db2 = DummyMummyDatabase.new
@@ -3111,7 +3267,7 @@ context "Dataset#table_exists?" do
 end
 
 context "Dataset#inspect" do
-  setup do
+  before do
     @ds = Sequel::Dataset.new(nil).from(:blah)
   end
   
@@ -3121,7 +3277,7 @@ context "Dataset#inspect" do
 end
 
 context "Dataset#all" do
-  setup do
+  before do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql, &block)
         block.call({:x => 1, :y => 2})
@@ -3140,7 +3296,7 @@ context "Dataset#all" do
     ]
   end
   
-  specify "should accept options and pass them to #each" do
+  deprec_specify "should accept options and pass them to #each" do
     @dataset.all(:limit => 33).should == [
       {:x => 1, :y => 2},
       {:x => 3, :y => 4},
@@ -3160,7 +3316,7 @@ context "Dataset#all" do
 end
 
 context "Dataset#grep" do
-  setup do
+  before do
     @ds = Sequel::Dataset.new(nil).from(:posts)
   end
   
@@ -3199,23 +3355,23 @@ context "Dataset#grep" do
 end
 
 context "Sequel.use_parse_tree" do
-  specify "be false" do
+  deprec_specify "be false" do
     Sequel.use_parse_tree.should == false
   end
 end
 
 context "Sequel.use_parse_tree=" do
-  specify "raise an error if true" do
+  deprec_specify "raise an error if true" do
     proc{Sequel.use_parse_tree = true}.should raise_error(Sequel::Error)
   end
 
-  specify "do nothing if false" do
+  deprec_specify "do nothing if false" do
     proc{Sequel.use_parse_tree = false}.should_not raise_error
   end
 end
 
 context "Dataset.dataset_classes" do
-  specify "should be an array of dataset subclasses" do
+  deprec_specify "should be an array of dataset subclasses" do
     ds_class = Class.new(Sequel::Dataset)
     Sequel::Dataset.dataset_classes.should be_a_kind_of(Array)
     Sequel::Dataset.dataset_classes.should include(ds_class)
@@ -3223,7 +3379,7 @@ context "Dataset.dataset_classes" do
 end
 
 context "Dataset default #fetch_rows, #insert, #update, and #delete, #execute" do
-  setup do
+  before do
     @db = Sequel::Database.new
     @ds = @db[:items]
   end
@@ -3254,9 +3410,9 @@ context "Dataset default #fetch_rows, #insert, #update, and #delete, #execute" d
 end
 
 context "Dataset prepared statements and bound variables " do
-  setup do
+  before do
     @db = Sequel::Database.new
-    @db.meta_eval{attr_accessor :sqls}
+    @db.send :metaattr_accessor, :sqls
     @db.sqls = []
     def @db.execute(sql, opts={})
       @sqls << sql
@@ -3342,9 +3498,9 @@ context "Dataset prepared statements and bound variables " do
 end
 
 context Sequel::Dataset::UnnumberedArgumentMapper do
-  setup do
+  before do
     @db = Sequel::Database.new
-    @db.meta_eval{attr_accessor :sqls}
+    @db.send :metaattr_accessor, :sqls
     @db.sqls = []
     def @db.execute(sql, opts={})
       @sqls << [sql, *opts[:arguments]]
@@ -3445,7 +3601,7 @@ context "Sequel::Dataset#each" do
     end
   end
 
-  specify "should not set the columns if passing an option that modifies them" do
+  deprec_specify "should not set the columns if passing an option that modifies them" do
     @ds.each(:select=>[:count]){}
     @ds.columns.should == [:a]
     @ds.each(:from=>[:count]){} 
@@ -3456,7 +3612,7 @@ context "Sequel::Dataset#each" do
     @ds.columns.should == [:a]
   end
 
-  specify "should have the correct columns inside the block regardless" do
+  deprec_specify "should have the correct columns inside the block regardless" do
     @ds.each(:select=>[:count]) do |x|
       x[:count].should == 'SELECT count FROM items'
       @ds.columns.should == [:count]