sequel 3.21.0 → 3.29.0

data/spec/core/expression_filters_spec.rb

@@ -6,7 +6,6 @@ String.send(:include, Sequel::SQL::StringMethods)
 describe "Blockless Ruby Filters" do
   before do
     db = Sequel::Database.new
-    db.quote_identifiers = false
     @d = db[:items]
     def @d.l(*args, &block)
       literal(filter_expr(*args, &block))
@@ -186,31 +185,26 @@ describe "Blockless Ruby Filters" do
     @d.l(~((((:x - :y)/(:x + :y))*:z) <= 100)).should == '((((x - y) / (x + y)) * z) > 100)'
   end
   
-  it "should not allow negation of string expressions" do
-    proc{~:x.sql_string}.should raise_error
-    proc{~([:x, :y].sql_string_join)}.should raise_error
+  it "should not add ~ method to string expressions" do
+    proc{~:x.sql_string}.should raise_error(NoMethodError) 
   end
 
-  it "should not allow mathematical or string operations on true, false, or nil" do
-    proc{:x + 1}.should_not raise_error
-    proc{:x - true}.should raise_error(Sequel::Error)
-    proc{:x / false}.should raise_error(Sequel::Error)
-    proc{:x * nil}.should raise_error(Sequel::Error)
-    proc{[:x, nil].sql_string_join}.should raise_error(Sequel::Error)
+  it "should allow mathematical or string operations on true, false, or nil" do
+    @d.lit(:x + 1).should == '(x + 1)'
+    @d.lit(:x - true).should == "(x - 't')"
+    @d.lit(:x / false).should == "(x / 'f')"
+    @d.lit(:x * nil).should == '(x * NULL)'
+    @d.lit([:x, nil].sql_string_join).should == '(x || NULL)'
   end
 
-  it "should not allow mathematical or string operations on boolean complex expressions" do
-    proc{:x + (:y + 1)}.should_not raise_error
-    proc{:x - (~:y)}.should raise_error(Sequel::Error)
-    proc{:x / (:y & :z)}.should raise_error(Sequel::Error)
-    proc{:x * (:y | :z)}.should raise_error(Sequel::Error)
-    proc{:x + :y.like('a')}.should raise_error(Sequel::Error)
-    proc{:x - :y.like(/a/)}.should raise_error(Sequel::Error)
-    proc{:x * :y.like(/a/i)}.should raise_error(Sequel::Error)
-    proc{:x + ~:y.like('a')}.should raise_error(Sequel::Error)
-    proc{:x - ~:y.like(/a/)}.should raise_error(Sequel::Error)
-    proc{:x * ~:y.like(/a/i)}.should raise_error(Sequel::Error)
-    proc{[:x, ~:y.like(/a/i)].sql_string_join}.should raise_error(Sequel::Error)
+  it "should allow mathematical or string operations on boolean complex expressions" do
+    @d.lit(:x + (:y + 1)).should == '(x + y + 1)'
+    @d.lit(:x - ~:y).should == '(x - NOT y)'
+    @d.lit(:x / (:y & :z)).should == '(x / (y AND z))'
+    @d.lit(:x * (:y | :z)).should == '(x * (y OR z))'
+    @d.lit(:x + :y.like('a')).should == "(x + (y LIKE 'a'))"
+    @d.lit(:x - ~:y.like('a')).should == "(x - (y NOT LIKE 'a'))"
+    @d.lit([:x, ~:y.like('a')].sql_string_join).should == "(x || (y NOT LIKE 'a'))"
   end
 
   it "should support AND conditions via &" do
@@ -382,12 +376,12 @@ describe "Blockless Ruby Filters" do
     @d.l((:x + 1) & (:x + 2) > 100).should == '(((x + 1) & (x + 2)) > 100)'
   end
 
-  it "should raise an error if use a Bitwise method on a ComplexExpression that isn't a NumericExpression" do
-    proc{(:x + 1) & (:x & 2)}.should raise_error(Sequel::Error)
+  it "should allow using a Bitwise method on a ComplexExpression that isn't a NumericExpression" do
+    @d.lit((:x + 1) & (:x + '2')).should == "((x + 1) & (x || '2'))"
   end
 
-  it "should raise an error if use a Boolean method on a ComplexExpression that isn't a BooleanExpression" do
-    proc{:x & (:x + 2)}.should raise_error(Sequel::Error)
+  it "should allow using a Boolean method on a ComplexExpression that isn't a BooleanExpression" do
+    @d.l(:x & (:x + '2')).should == "(x AND (x || '2'))"
   end
 
   it "should raise an error if attempting to invert a ComplexExpression that isn't a BooleanExpression" do
@@ -424,10 +418,94 @@ describe "Blockless Ruby Filters" do
     @d.l(~{:x => Sequel::SQLFALSE}).should == '(x IS NOT FALSE)'
   end
   
+  it "should support direct negation of SQL::Constants" do
+    @d.l({:x => ~Sequel::NULL}).should == '(x IS NOT NULL)'
+    @d.l({:x => ~Sequel::NOTNULL}).should == '(x IS NULL)'
+    @d.l({:x => ~Sequel::TRUE}).should == '(x IS FALSE)'
+    @d.l({:x => ~Sequel::FALSE}).should == '(x IS TRUE)'
+    @d.l({:x => ~Sequel::SQLTRUE}).should == '(x IS FALSE)'
+    @d.l({:x => ~Sequel::SQLFALSE}).should == '(x IS TRUE)'
+  end
+  
+  it "should raise an error if trying to invert an invalid SQL::Constant" do
+    proc{~Sequel::CURRENT_DATE}.should raise_error(Sequel::Error)
+  end
+
   it "should raise an error if trying to create an invalid complex expression" do
     proc{Sequel::SQL::ComplexExpression.new(:BANG, 1, 2)}.should raise_error(Sequel::Error)
   end
 
+  it "should use a string concatentation for + if given a string" do
+    @d.lit(:x + '1').should == "(x || '1')"
+    @d.lit(:x + '1' + '1').should == "(x || '1' || '1')"
+  end
+
+  it "should use an addition for + if given a literal string" do
+    @d.lit(:x + '1'.lit).should == "(x + 1)"
+    @d.lit(:x + '1'.lit + '1'.lit).should == "(x + 1 + 1)"
+  end
+
+  it "should use a bitwise operator for & and | if given an integer" do
+    @d.lit(:x & 1).should == "(x & 1)"
+    @d.lit(:x | 1).should == "(x | 1)"
+    @d.lit(:x & 1 & 1).should == "(x & 1 & 1)"
+    @d.lit(:x | 1 | 1).should == "(x | 1 | 1)"
+  end
+  
+  it "should allow adding a string to an integer expression" do
+    @d.lit(:x + 1 + 'a').should == "(x + 1 + 'a')"
+  end
+
+  it "should allow adding an integer to an string expression" do
+    @d.lit(:x + 'a' + 1).should == "(x || 'a' || 1)"
+  end
+
+  it "should allow adding a boolean to an integer expression" do
+    @d.lit(:x + 1 + true).should == "(x + 1 + 't')"
+  end
+
+  it "should allow adding a boolean to an string expression" do
+    @d.lit(:x + 'a' + true).should == "(x || 'a' || 't')"
+  end
+
+  it "should allow using a boolean operation with an integer on an boolean expression" do
+    @d.lit(:x & :a & 1).should == "(x AND a AND 1)"
+  end
+
+  it "should allow using a boolean operation with a string on an boolean expression" do
+    @d.lit(:x & :a & 'a').should == "(x AND a AND 'a')"
+  end
+
+  it "should allowing AND of boolean expression and literal string" do
+   @d.lit(:x & :a & 'a'.lit).should == "(x AND a AND a)"
+  end
+
+  it "should allowing + of integer expression and literal string" do
+   @d.lit(:x + :a + 'a'.lit).should == "(x + a + a)"
+  end
+
+  it "should allowing + of string expression and literal string" do
+   @d.lit(:x + 'a' + 'a'.lit).should == "(x || 'a' || a)"
+  end
+
+  it "should allow sql_{string,boolean,number} methods on numeric expressions" do
+   @d.lit((:x + 1).sql_string + 'a').should == "((x + 1) || 'a')"
+   @d.lit((:x + 1).sql_boolean & 1).should == "((x + 1) AND 1)"
+   @d.lit((:x + 1).sql_number + 'a').should == "(x + 1 + 'a')"
+  end
+
+  it "should allow sql_{string,boolean,number} methods on string expressions" do
+   @d.lit((:x + 'a').sql_string + 'a').should == "(x || 'a' || 'a')"
+   @d.lit((:x + 'a').sql_boolean & 1).should == "((x || 'a') AND 1)"
+   @d.lit((:x + 'a').sql_number + 'a').should == "((x || 'a') + 'a')"
+  end
+
+  it "should allow sql_{string,boolean,number} methods on boolean expressions" do
+   @d.lit((:x & :y).sql_string + 'a').should == "((x AND y) || 'a')"
+   @d.lit((:x & :y).sql_boolean & 1).should == "(x AND y AND 1)"
+   @d.lit((:x & :y).sql_number + 'a').should == "((x AND y) + 'a')"
+  end
+
   it "should raise an error if trying to literalize an invalid complex expression" do
     ce = :x + 1
     ce.instance_variable_set(:@op, :BANG)
@@ -439,26 +517,65 @@ describe "Blockless Ruby Filters" do
     e2 = ~:comment.like('%:hidden:%')
     e1.should == e2
   end
+
+  it "should support expression filter methods on Datasets" do
+    d = @d.select(:a)
+
+    @d.lit(d + 1).should == '((SELECT a FROM items) + 1)'
+    @d.lit(d - 1).should == '((SELECT a FROM items) - 1)'
+    @d.lit(d * 1).should == '((SELECT a FROM items) * 1)'
+    @d.lit(d / 1).should == '((SELECT a FROM items) / 1)'
+
+    @d.lit(d => 1).should == '((SELECT a FROM items) = 1)'
+    @d.lit(~{d => 1}).should == '((SELECT a FROM items) != 1)'
+    @d.lit(d > 1).should == '((SELECT a FROM items) > 1)'
+    @d.lit(d < 1).should == '((SELECT a FROM items) < 1)'
+    @d.lit(d >= 1).should == '((SELECT a FROM items) >= 1)'
+    @d.lit(d <= 1).should == '((SELECT a FROM items) <= 1)'
+
+    @d.lit(d.as(:b)).should == '(SELECT a FROM items) AS b'
+
+    @d.lit(d & :b).should == '((SELECT a FROM items) AND b)'
+    @d.lit(d | :b).should == '((SELECT a FROM items) OR b)'
+    @d.lit(~d).should == 'NOT (SELECT a FROM items)'
+
+    @d.lit(d.cast(Integer)).should == 'CAST((SELECT a FROM items) AS integer)'
+    @d.lit(d.cast_numeric).should == 'CAST((SELECT a FROM items) AS integer)'
+    @d.lit(d.cast_string).should == 'CAST((SELECT a FROM items) AS varchar(255))'
+    @d.lit(d.cast_numeric << :b).should == '(CAST((SELECT a FROM items) AS integer) << b)'
+    @d.lit(d.cast_string + :b).should == '(CAST((SELECT a FROM items) AS varchar(255)) || b)'
+
+    @d.lit(d.extract(:year)).should == 'extract(year FROM (SELECT a FROM items))'
+    @d.lit(d.sql_boolean & :b).should == '((SELECT a FROM items) AND b)'
+    @d.lit(d.sql_number << :b).should == '((SELECT a FROM items) << b)'
+    @d.lit(d.sql_string + :b).should == '((SELECT a FROM items) || b)'
+
+    @d.lit(d.asc).should == '(SELECT a FROM items) ASC'
+    @d.lit(d.desc).should == '(SELECT a FROM items) DESC'
+
+    @d.lit(d.like(:b)).should == '((SELECT a FROM items) LIKE b)'
+    @d.lit(d.ilike(:b)).should == '((SELECT a FROM items) ILIKE b)'
+  end
   
   if RUBY_VERSION < '1.9.0'
     it "should not allow inequality operations on true, false, or nil" do
-      proc{:x > 1}.should_not raise_error
-      proc{:x < true}.should raise_error(Sequel::Error)
-      proc{:x >= false}.should raise_error(Sequel::Error)
-      proc{:x <= nil}.should raise_error(Sequel::Error)
+      @d.lit(:x > 1).should == "(x > 1)"
+      @d.lit(:x < true).should == "(x < 't')"
+      @d.lit(:x >= false).should == "(x >= 'f')"
+      @d.lit(:x <= nil).should == "(x <= NULL)"
     end
 
     it "should not allow inequality operations on boolean complex expressions" do
-      proc{:x > (:y > 5)}.should raise_error(Sequel::Error)
-      proc{:x < (:y < 5)}.should raise_error(Sequel::Error)
-      proc{:x >= (:y >= 5)}.should raise_error(Sequel::Error)
-      proc{:x <= (:y <= 5)}.should raise_error(Sequel::Error)
-      proc{:x > {:y => nil}}.should raise_error(Sequel::Error)
-      proc{:x < ~{:y => nil}}.should raise_error(Sequel::Error)
-      proc{:x >= {:y => 5}}.should raise_error(Sequel::Error)
-      proc{:x <= ~{:y => 5}}.should raise_error(Sequel::Error)
-      proc{:x >= {:y => [1,2,3]}}.should raise_error(Sequel::Error)
-      proc{:x <= ~{:y => [1,2,3]}}.should raise_error(Sequel::Error)
+      @d.lit(:x > (:y > 5)).should == "(x > (y > 5))"
+      @d.lit(:x < (:y < 5)).should == "(x < (y < 5))"
+      @d.lit(:x >= (:y >= 5)).should == "(x >= (y >= 5))"
+      @d.lit(:x <= (:y <= 5)).should == "(x <= (y <= 5))"
+      @d.lit(:x > {:y => nil}).should == "(x > (y IS NULL))"
+      @d.lit(:x < ~{:y => nil}).should == "(x < (y IS NOT NULL))"
+      @d.lit(:x >= {:y => 5}).should == "(x >= (y = 5))"
+      @d.lit(:x <= ~{:y => 5}).should == "(x <= (y != 5))"
+      @d.lit(:x >= {:y => [1,2,3]}).should == "(x >= (y IN (1, 2, 3)))"
+      @d.lit(:x <= ~{:y => [1,2,3]}).should == "(x <= (y NOT IN (1, 2, 3)))"
     end
     
     it "should support >, <, >=, and <= via Symbol#>,<,>=,<=" do
@@ -553,7 +670,7 @@ describe Sequel::SQL::VirtualRow do
   end
 
   it "should support :frame=>:rows option for window function calls" do
-    @d.l{rank(:over, :frame=>:rows){}}.should == 'rank() OVER (ROWS UNBOUNDED PRECEDING)'
+    @d.l{rank(:over, :frame=>:rows){}}.should == 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
   end
 
   it "should support :frame=>'some string' option for window function calls" do
@@ -565,7 +682,7 @@ describe Sequel::SQL::VirtualRow do
   end
 
   it "should support all these options together" do
-    @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.should == 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS UNBOUNDED PRECEDING)'
+    @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.should == 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
   end
 
   it "should raise an error if window functions are not supported" do

data/spec/core/mock_adapter_spec.rb

@@ -0,0 +1,378 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel Mock Adapter" do
+  specify "should have an adapter method" do
+    db = Sequel.mock
+    db.should be_a_kind_of(Sequel::Mock::Database)
+    db.adapter_scheme.should == :mock
+  end
+
+  specify "should each not return any rows by default" do
+    called = false
+    Sequel.mock[:t].each{|r| called = true}
+    called.should be_false
+  end
+
+  specify "should return 0 for update and delete by default" do
+    Sequel.mock[:t].update(:a=>1).should == 0
+    Sequel.mock[:t].delete.should == 0
+  end
+
+  specify "should return nil for insert by default" do
+    Sequel.mock[:t].insert(:a=>1).should be_nil
+  end
+
+  specify "should be able to set the rows returned by each using :fetch option with a single hash" do
+    rs = []
+    db = Sequel.mock(:fetch=>{:a=>1})
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>1}]
+    db[:t].each{|r| r[:a] = 2; rs << r}
+    rs.should == [{:a=>1}, {:a=>1}, {:a=>2}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>1}, {:a=>2}, {:a=>1}]
+  end
+
+  specify "should be able to set the rows returned by each using :fetch option with an array of hashes" do
+    rs = []
+    db = Sequel.mock(:fetch=>[{:a=>1}, {:a=>2}])
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}, {:a=>1}, {:a=>2}]
+    db[:t].each{|r| r[:a] += 2; rs << r}
+    rs.should == [{:a=>1}, {:a=>2}, {:a=>1}, {:a=>2}, {:a=>3}, {:a=>4}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}, {:a=>1}, {:a=>2}, {:a=>3}, {:a=>4}, {:a=>1}, {:a=>2}]
+  end
+
+  specify "should be able to set the rows returned by each using :fetch option with an array or arrays of hashes" do
+    rs = []
+    db = Sequel.mock(:fetch=>[[{:a=>1}, {:a=>2}], [{:a=>3}, {:a=>4}]])
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}, {:a=>3}, {:a=>4}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}, {:a=>3}, {:a=>4}]
+  end
+
+  specify "should be able to set the rows returned by each using :fetch option with a proc that takes sql" do
+    rs = []
+    db = Sequel.mock(:fetch=>proc{|sql| sql =~ /FROM t/ ? {:b=>1} : [{:a=>1}, {:a=>2}]})
+    db[:t].each{|r| rs << r}
+    rs.should == [{:b=>1}]
+    db[:b].each{|r| rs << r}
+    rs.should == [{:b=>1}, {:a=>1}, {:a=>2}]
+    db[:t].each{|r| r[:b] += 1; rs << r}
+    db[:b].each{|r| r[:a] += 2; rs << r}
+    rs.should == [{:b=>1}, {:a=>1}, {:a=>2}, {:b=>2}, {:a=>3}, {:a=>4}]
+    db[:t].each{|r| rs << r}
+    db[:b].each{|r| rs << r}
+    rs.should == [{:b=>1}, {:a=>1}, {:a=>2}, {:b=>2}, {:a=>3}, {:a=>4}, {:b=>1}, {:a=>1}, {:a=>2}]
+  end
+
+  specify "should have a fetch= method for setting rows returned by each after the fact" do
+    rs = []
+    db = Sequel.mock
+    db.fetch = {:a=>1}
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}] * 2
+  end
+
+  specify "should be able to set an exception to raise by setting the :fetch option to an exception class " do
+    db = Sequel.mock(:fetch=>ArgumentError)
+    proc{db[:t].all}.should raise_error(Sequel::DatabaseError)
+    begin
+      db[:t].all
+    rescue => e
+    end
+    e.should be_a_kind_of(Sequel::DatabaseError)
+    e.wrapped_exception.should be_a_kind_of(ArgumentError) 
+  end
+
+  specify "should be able to set separate kinds of results for fetch using an array" do
+    rs = []
+    db = Sequel.mock(:fetch=>[{:a=>1}, [{:a=>2}, {:a=>3}], proc{|s| {:a=>4}}, proc{|s| }, nil, ArgumentError])
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}, {:a=>3}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}, {:a=>3}, {:a=>4}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}, {:a=>3}, {:a=>4}]
+    db[:t].each{|r| rs << r}
+    rs.should == [{:a=>1}, {:a=>2}, {:a=>3}, {:a=>4}]
+    proc{db[:t].all}.should raise_error(Sequel::DatabaseError)
+  end
+
+  specify "should be able to set the rows returned by each on a per dataset basis using _fetch" do
+    rs = []
+    db = Sequel.mock(:fetch=>{:a=>1})
+    ds = db[:t]
+    ds.each{|r| rs << r}
+    rs.should == [{:a=>1}]
+    ds._fetch = {:b=>2}
+    ds.each{|r| rs << r}
+    rs.should == [{:a=>1}, {:b=>2}]
+  end
+
+  specify "should be able to set the number of rows modified by update and delete using :numrows option as an integer" do
+    db = Sequel.mock(:numrows=>2)
+    db[:t].update(:a=>1).should == 2
+    db[:t].delete.should == 2
+    db[:t].update(:a=>1).should == 2
+    db[:t].delete.should == 2
+  end
+
+  specify "should be able to set the number of rows modified by update and delete using :numrows option as an array of integers" do
+    db = Sequel.mock(:numrows=>[2, 1])
+    db[:t].update(:a=>1).should == 2
+    db[:t].delete.should == 1
+    db[:t].update(:a=>1).should == 0
+    db[:t].delete.should == 0
+  end
+
+  specify "should be able to set the number of rows modified by update and delete using :numrows option as a proc" do
+    db = Sequel.mock(:numrows=>proc{|sql| sql =~ / t/ ? 2 : 1})
+    db[:t].update(:a=>1).should == 2
+    db[:t].delete.should == 2
+    db[:b].update(:a=>1).should == 1
+    db[:b].delete.should == 1
+  end
+
+  specify "should be able to set an exception to raise by setting the :numrows option to an exception class " do
+    db = Sequel.mock(:numrows=>ArgumentError)
+    proc{db[:t].update(:a=>1)}.should raise_error(Sequel::DatabaseError)
+    begin
+      db[:t].delete
+    rescue => e
+    end
+    e.should be_a_kind_of(Sequel::DatabaseError)
+    e.wrapped_exception.should be_a_kind_of(ArgumentError) 
+  end
+
+  specify "should be able to set separate kinds of results for numrows using an array" do
+    db = Sequel.mock(:numrows=>[1, proc{|s| 2}, nil, ArgumentError])
+    db[:t].delete.should == 1
+    db[:t].update(:a=>1).should == 2
+    db[:t].delete.should == 0
+    proc{db[:t].delete}.should raise_error(Sequel::DatabaseError)
+  end
+
+  specify "should have a numrows= method to set the number of rows modified by update and delete after the fact" do
+    db = Sequel.mock
+    db.numrows = 2
+    db[:t].update(:a=>1).should == 2
+    db[:t].delete.should == 2
+    db[:t].update(:a=>1).should == 2
+    db[:t].delete.should == 2
+  end
+
+  specify "should be able to set the number of rows modified by update and delete on a per dataset basis" do
+    db = Sequel.mock(:numrows=>2)
+    ds = db[:t]
+    ds.update(:a=>1).should == 2
+    ds.delete.should == 2
+    ds.numrows = 3
+    ds.update(:a=>1).should == 3
+    ds.delete.should == 3
+  end
+
+  specify "should be able to set the autogenerated primary key returned by insert using :autoid option as an integer" do
+    db = Sequel.mock(:autoid=>1)
+    db[:t].insert(:a=>1).should == 1
+    db[:t].insert(:a=>1).should == 2
+    db[:t].insert(:a=>1).should == 3
+  end
+
+  specify "should be able to set the autogenerated primary key returned by insert using :autoid option as an array of integers" do
+    db = Sequel.mock(:autoid=>[1, 3, 5])
+    db[:t].insert(:a=>1).should == 1
+    db[:t].insert(:a=>1).should == 3
+    db[:t].insert(:a=>1).should == 5
+    db[:t].insert(:a=>1).should be_nil
+  end
+
+  specify "should be able to set the autogenerated primary key returned by insert using :autoid option as a proc" do
+    db = Sequel.mock(:autoid=>proc{|sql| sql =~ /INTO t / ? 2 : 1})
+    db[:t].insert(:a=>1).should == 2
+    db[:t].insert(:a=>1).should == 2
+    db[:b].insert(:a=>1).should == 1
+    db[:b].insert(:a=>1).should == 1
+  end
+
+  specify "should be able to set an exception to raise by setting the :autoid option to an exception class " do
+    db = Sequel.mock(:autoid=>ArgumentError)
+    proc{db[:t].insert(:a=>1)}.should raise_error(Sequel::DatabaseError)
+    begin
+      db[:t].insert
+    rescue => e
+    end
+    e.should be_a_kind_of(Sequel::DatabaseError)
+    e.wrapped_exception.should be_a_kind_of(ArgumentError) 
+  end
+
+  specify "should be able to set separate kinds of results for autoid using an array" do
+    db = Sequel.mock(:autoid=>[1, proc{|s| 2}, nil, ArgumentError])
+    db[:t].insert.should == 1
+    db[:t].insert.should == 2
+    db[:t].insert.should == nil
+    proc{db[:t].insert}.should raise_error(Sequel::DatabaseError)
+  end
+
+  specify "should have an autoid= method to set the autogenerated primary key returned by insert after the fact" do
+    db = Sequel.mock
+    db.autoid = 1
+    db[:t].insert(:a=>1).should == 1
+    db[:t].insert(:a=>1).should == 2
+    db[:t].insert(:a=>1).should == 3
+  end
+
+  specify "should be able to set the autogenerated primary key returned by insert on a per dataset basis" do
+    db = Sequel.mock(:autoid=>1)
+    ds = db[:t]
+    ds.insert(:a=>1).should == 1
+    ds.autoid = 5
+    ds.insert(:a=>1).should == 5
+    ds.insert(:a=>1).should == 6
+    db[:t].insert(:a=>1).should == 2
+  end
+
+  specify "should be able to set the columns to set in the dataset as an array of symbols" do
+    db = Sequel.mock(:columns=>[:a, :b])
+    db[:t].columns.should == [:a, :b]
+    db.sqls.should == ["SELECT * FROM t LIMIT 1"]
+    ds = db[:t]
+    ds.all
+    db.sqls.should == ["SELECT * FROM t"]
+    ds.columns.should == [:a, :b]
+    db.sqls.should == []
+    db[:t].columns.should == [:a, :b]
+  end
+
+  specify "should be able to set the columns to set in the dataset as an array of arrays of symbols" do
+    db = Sequel.mock(:columns=>[[:a, :b], [:c, :d]])
+    db[:t].columns.should == [:a, :b]
+    db[:t].columns.should == [:c, :d]
+  end
+
+  specify "should be able to set the columns to set in the dataset as a proc" do
+    db = Sequel.mock(:columns=>proc{|sql| (sql =~ / t/) ? [:a, :b] : [:c, :d]})
+    db[:b].columns.should == [:c, :d]
+    db[:t].columns.should == [:a, :b]
+  end
+
+  specify "should have a columns= method to set the columns to set after the fact" do
+    db = Sequel.mock
+    db.columns = [[:a, :b], [:c, :d]]
+    db[:t].columns.should == [:a, :b]
+    db[:t].columns.should == [:c, :d]
+  end
+
+  specify "should keep a record of all executed SQL in #sqls" do
+    db = Sequel.mock
+    db[:t].all
+    db[:b].delete
+    db[:c].insert(:a=>1)
+    db[:d].update(:a=>1)
+    db.sqls.should == ['SELECT * FROM t', 'DELETE FROM b', 'INSERT INTO c (a) VALUES (1)', 'UPDATE d SET a = 1']
+  end
+
+  specify "should clear sqls on retrieval" do
+    db = Sequel.mock
+    db[:t].all
+    db.sqls.should == ['SELECT * FROM t']
+    db.sqls.should == []
+  end
+
+  specify "should also log SQL executed to the given loggers" do
+    a = []
+    def a.method_missing(m, *x) push(*x) end
+    db = Sequel.mock(:loggers=>[a])
+    db[:t].all
+    db[:b].delete
+    db[:c].insert(:a=>1)
+    db[:d].update(:a=>1)
+    a.should == ['SELECT * FROM t', 'DELETE FROM b', 'INSERT INTO c (a) VALUES (1)', 'UPDATE d SET a = 1']
+  end
+
+  specify "should correctly handle transactions" do
+    db = Sequel.mock
+    db.transaction{db[:a].all}
+    db.sqls.should == ['BEGIN', 'SELECT * FROM a', 'COMMIT']
+    db.transaction{db[:a].all; raise Sequel::Rollback}
+    db.sqls.should == ['BEGIN', 'SELECT * FROM a', 'ROLLBACK']
+    proc{db.transaction{db[:a].all; raise ArgumentError}}.should raise_error(ArgumentError)
+    db.sqls.should == ['BEGIN', 'SELECT * FROM a', 'ROLLBACK']
+    proc{db.transaction(:rollback=>:reraise){db[:a].all; raise Sequel::Rollback}}.should raise_error(Sequel::Rollback)
+    db.sqls.should == ['BEGIN', 'SELECT * FROM a', 'ROLLBACK']
+    db.transaction(:rollback=>:always){db[:a].all}
+    db.sqls.should == ['BEGIN', 'SELECT * FROM a', 'ROLLBACK']
+    db.transaction{db.transaction{db[:a].all; raise Sequel::Rollback}}
+    db.sqls.should == ['BEGIN', 'SELECT * FROM a', 'ROLLBACK']
+    db.transaction{db.transaction(:savepoint=>true){db[:a].all; raise Sequel::Rollback}}
+    db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'SELECT * FROM a', 'ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT']
+    db.transaction{db.transaction(:savepoint=>true){db[:a].all}; raise Sequel::Rollback}
+    db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'SELECT * FROM a', 'RELEASE SAVEPOINT autopoint_1', 'ROLLBACK']
+  end
+
+  specify "should correctly handle transactions when sharding" do
+    db = Sequel.mock(:servers=>{:test=>{}})
+    db.transaction{db.transaction(:server=>:test){db[:a].all; db[:t].server(:test).all}}
+    db.sqls.should == ['BEGIN', 'BEGIN -- test', 'SELECT * FROM a', 'SELECT * FROM t -- test', 'COMMIT -- test', 'COMMIT']
+  end
+
+  specify "should yield a mock connection object from synchronize" do
+    c = Sequel.mock.synchronize{|conn| conn}
+    c.should be_a_kind_of(Sequel::Mock::Connection)
+  end
+
+  specify "should deal correctly with sharding" do
+    db = Sequel.mock(:servers=>{:test=>{}})
+    c1 = db.synchronize{|conn| conn}
+    c2 = db.synchronize(:test){|conn| conn}
+    c1.server.should == :default
+    c2.server.should == :test
+  end
+
+  specify "should disconnect correctly" do
+    db = Sequel.mock
+    db.test_connection
+    proc{db.disconnect}.should_not raise_error
+  end
+
+  specify "should accept :extend option for extending the object with a module" do
+    Sequel.mock(:extend=>Module.new{def foo(v) v * 2 end}).foo(3).should == 6
+  end
+
+  specify "should accept :sqls option for where to store the SQL queries" do
+    a = []
+    Sequel.mock(:sqls=>a)[:t].all
+    a.should == ['SELECT * FROM t']
+  end
+
+  specify "should include :append option in SQL if it is given" do
+    db = Sequel.mock(:append=>'a')
+    db[:t].all
+    db.sqls.should == ['SELECT * FROM t -- a']
+  end
+
+  specify "should append :arguments option to execute to the SQL if present" do
+    db = Sequel.mock
+    db.execute('SELECT * FROM t', :arguments=>[1, 2])
+    db.sqls.should == ['SELECT * FROM t -- args: [1, 2]']
+  end
+
+  specify "should have Dataset#columns take columns to set and return self" do
+    db = Sequel.mock
+    ds = db[:t].columns(:id, :a, :b)
+    ds.should be_a_kind_of(Sequel::Mock::Dataset)
+    ds.columns.should == [:id, :a, :b]
+  end
+end