sequel 2.7.1 → 2.8.0

data/spec/adapters/mysql_spec.rb

@@ -12,7 +12,6 @@ unless defined?(MYSQL_SOCKET_FILE)
 end
 
 MYSQL_URI = URI.parse(MYSQL_DB.uri)
-MYSQL_DB_NAME = (m = /\/(.*)/.match(MYSQL_URI.path)) && m[1]
 
 MYSQL_DB.create_table! :items do
   text :name
@@ -482,23 +481,32 @@ context "A MySQL database" do
     @db << 'DELETE FROM items'
     @db[:items].first.should == nil
   end
+  
+  specify "should handle multiple select statements at once" do
+    @db << 'DELETE FROM items; '
+    
+    @db[:items].delete
+    @db[:items].insert(:name => 'tutu', :value => 1234)
+    @db["SELECT * FROM items; SELECT * FROM items"].all.should == \
+      [{:name => 'tutu', :value => 1234}, {:name => 'tutu', :value => 1234}]
+  end
 end  
 
 # Socket tests should only be run if the MySQL server is on localhost
 if %w'localhost 127.0.0.1 ::1'.include? MYSQL_URI.host
   context "A MySQL database" do
     specify "should accept a socket option" do
-      db = Sequel.mysql(MYSQL_DB_NAME, :host => 'localhost', :user => MYSQL_USER, :socket => MYSQL_SOCKET_FILE)
+      db = Sequel.mysql(MYSQL_DB.opts[:database], :host => 'localhost', :user => MYSQL_DB.opts[:user], :password => MYSQL_DB.opts[:password], :socket => MYSQL_SOCKET_FILE)
       proc {db.test_connection}.should_not raise_error
     end
     
     specify "should accept a socket option without host option" do
-      db = Sequel.mysql(MYSQL_DB_NAME, :user => MYSQL_USER, :socket => MYSQL_SOCKET_FILE)
+      db = Sequel.mysql(MYSQL_DB.opts[:database], :user => MYSQL_DB.opts[:user], :password => MYSQL_DB.opts[:password], :socket => MYSQL_SOCKET_FILE)
       proc {db.test_connection}.should_not raise_error
     end
     
     specify "should fail to connect with invalid socket" do
-      db = Sequel.mysql(MYSQL_DB_NAME, :host => 'localhost', :user => MYSQL_USER, :socket => 'blah')
+      db = Sequel.mysql(MYSQL_DB.opts[:database], :user => MYSQL_DB.opts[:user], :password => MYSQL_DB.opts[:password], :socket =>'blah')
       proc {db.test_connection}.should raise_error
     end
   end
@@ -761,3 +769,28 @@ context "MySQL::Dataset#complex_expression_sql" do
     @d.literal([:x].sql_string_join(' ')).should == "x"
   end
 end
+
+context "MySQL Stored Procedures" do
+  teardown do
+    MYSQL_DB.execute('DROP PROCEDURE test_sproc')
+  end
+  
+  specify "should be callable on the database object" do
+    MYSQL_DB.execute('CREATE PROCEDURE test_sproc() BEGIN DELETE FROM items; END')
+    MYSQL_DB[:items].delete
+    MYSQL_DB[:items].insert(:value=>1)
+    MYSQL_DB[:items].count.should == 1
+    MYSQL_DB.call_sproc(:test_sproc)
+    MYSQL_DB[:items].count.should == 0
+  end
+  
+  specify "should be callable on the dataset object" do
+    MYSQL_DB.execute('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
+    @d = MYSQL_DB[:items]
+    @d.call_sproc(:select, :test_sproc, 3).should == []
+    @d.insert(:value=>1)
+    @d.call_sproc(:select, :test_sproc, 4).should == [{:id=>nil, :value=>1, :b=>4}]
+    @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
+    @d.call_sproc(:select, :test_sproc, 3).should == [{:id=>nil, :value=>2, :b=>6}]
+  end
+end

data/spec/adapters/oracle_spec.rb

@@ -71,7 +71,7 @@ context "An Oracle dataset" do
       {:name => 'def'}
     ]
            
-    @d.order(:value.DESC).limit(1).to_a.should == [
+    @d.order(:value.desc).limit(1).to_a.should == [
       {:name => 'def', :value => 789}                                        
     ]
 
@@ -80,7 +80,7 @@ context "An Oracle dataset" do
       {:name => 'abc', :value => 456} 
     ]
     
-    @d.order(:value.DESC).filter(:name => 'abc').to_a.should == [
+    @d.order(:value.desc).filter(:name => 'abc').to_a.should == [
       {:name => 'abc', :value => 456},
       {:name => 'abc', :value => 123} 
     ]
@@ -89,7 +89,7 @@ context "An Oracle dataset" do
       {:name => 'abc', :value => 123}                                        
     ]
         
-    @d.filter(:name => 'abc').order(:value.DESC).limit(1).to_a.should == [
+    @d.filter(:name => 'abc').order(:value.desc).limit(1).to_a.should == [
       {:name => 'abc', :value => 456}                                        
     ]
     
@@ -214,9 +214,31 @@ context "Joined Oracle dataset" do
       {:id => 4, :title => 'ddd', :cat_name => nil} 
     ]
     
-    @d1.left_outer_join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id.DESC).limit(2, 0).to_a.should == [      
+    @d1.left_outer_join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id.desc).limit(2, 0).to_a.should == [      
       {:id => 4, :title => 'ddd', :cat_name => nil}, 
       {:id => 3, :title => 'ccc', :cat_name => 'rails'}
     ]      
   end  
 end
+
+context "Oracle aliasing" do
+  setup do
+    @d1 = ORACLE_DB[:books]
+    @d1.delete # remove all records
+    @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
+    @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
+    @d1 << {:id => 3, :title => 'bbb', :category_id => 100}
+  end
+
+  specify "should allow columns to be renamed" do
+    @d1.select(:title.as(:name)).order_by(:id).to_a.should == [
+      { :name => 'aaa' },
+      { :name => 'bbb' },
+      { :name => 'bbb' },
+    ]
+  end
+
+  specify "nested queries should work" do
+    @d1.select(:title).group_by(:title).count.should == 2
+  end
+end

data/spec/adapters/sqlite_spec.rb

@@ -415,6 +415,13 @@ context "A SQLite database" do
     @db[:test2].first.should == {:name => 'mmm'}
   end
   
+  specify "should support drop_column operations in a transaction" do
+    @db.transaction{@db.drop_column :test2, :value}
+    @db[:test2].columns.should == [:name]
+    @db[:test2] << {:name => 'mmm'}
+    @db[:test2].first.should == {:name => 'mmm'}
+  end
+  
   specify "should not support rename_column operations" do
     proc {@db.rename_column :test2, :value, :zyx}.should raise_error(Sequel::Error)
   end

data/spec/integration/prepared_statement_test.rb

@@ -24,6 +24,30 @@ describe "Prepared Statements and Bound Arguments" do
     @ds.filter(:number=>@ds.ba(:$n)).call(:first, :n=>10).should == {:id=>1, :number=>10}
   end
 
+  specify "should support placeholder literal strings" do
+    @ds.filter("number = ?", @ds.ba(:$n)).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support datasets with static sql and placeholders" do
+    INTEGRATION_DB["SELECT * FROM items WHERE number = ?", @ds.ba(:$n)].call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support subselects" do
+    @ds.filter(:id=>:$i).filter(:number=>@ds.select(:number).filter(:number=>@ds.ba(:$n))).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support subselects with literal strings" do
+    @ds.filter(:id=>:$i, :number=>@ds.select(:number).filter("number = ?", @ds.ba(:$n))).call(:select, :n=>10, :i=>1).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support subselects with static sql and placeholders" do
+    @ds.filter(:id=>:$i, :number=>INTEGRATION_DB["SELECT number FROM items WHERE number = ?", @ds.ba(:$n)]).call(:select, :n=>10, :i=>1).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support subselects of subselects" do
+    @ds.filter(:id=>:$i).filter(:number=>@ds.select(:number).filter(:number=>@ds.select(:number).filter(:number=>@ds.ba(:$n)))).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).should == [{:id=>1, :number=>10}]
+  end
+
   specify "should support bound variables with insert" do
     @ds.call(:insert, {:n=>20, :i=>100}, :id=>@ds.ba(:$i), :number=>@ds.ba(:$n))
     @ds.count.should == 2

data/spec/integration/schema_test.rb

@@ -9,7 +9,7 @@ describe "Database schema parser" do
     INTEGRATION_DB.create_table!(:items){integer :number}
     schema = INTEGRATION_DB.schema(nil, :reload=>true)
     schema.should be_a_kind_of(Hash)
-    schema.should include(:items)
+    schema[:items].should_not == nil
   end
 
   specify "should not issue an sql query if the schema has been loaded unless :reload is true" do

data/spec/sequel_core/connection_pool_spec.rb

@@ -23,7 +23,7 @@ end
 context "A connection pool handling connections" do
   setup do
     @max_size = 2
-    @cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>@max_size)) {:got_connection}
+    @cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3},  :max_connections=>@max_size)) {:got_connection}
   end
 
   specify "#hold should increment #created_count" do
@@ -61,6 +61,31 @@ context "A connection pool handling connections" do
     @cpool.send(:make_new, :default).should == nil
     @cpool.created_count.should == 2
   end
+
+  specify ":disconnection_proc option should set the disconnection proc to use" do
+    @max_size.should == 2
+    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
+    @max_size.should == 3
+  end
+
+  specify "#disconnection_proc= should set the disconnection proc to use" do
+    a = 1
+    @cpool.disconnection_proc = proc{|c| a += 1}
+    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
+    a.should == 2
+  end
+
+  specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
+    @cpool.created_count.should == 0
+    @cpool.hold{Thread.new{@cpool.hold{}}; sleep 0.01}
+    @cpool.created_count.should == 2
+    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
+    @cpool.created_count.should == 1
+    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
+    @cpool.created_count.should == 0
+    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
+    @cpool.created_count.should == 0
+  end
 end
 
 class DummyConnection
@@ -423,7 +448,8 @@ end
 
 context "A single threaded pool with multiple servers" do
   setup do
-    @pool = Sequel::SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}})){|server| server}
+    @max_size=2
+    @pool = Sequel::SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3}, :servers=>{:read_only=>{}})){|server| server}
   end
   
   specify "should use the :default server by default" do
@@ -462,4 +488,25 @@ context "A single threaded pool with multiple servers" do
     @pool.conn.should == nil
     @pool.conn(:read_only).should == nil
   end
+
+  specify ":disconnection_proc option should set the disconnection proc to use" do
+    @max_size.should == 2
+    proc{@pool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
+    @max_size.should == 3
+  end
+
+  specify "#disconnection_proc= should set the disconnection proc to use" do
+    a = 1
+    @pool.disconnection_proc = proc{|c| a += 1}
+    proc{@pool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
+    a.should == 2
+  end
+
+  specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
+    @pool.instance_variable_get(:@conns).length.should == 0
+    @pool.hold{}
+    @pool.instance_variable_get(:@conns).length.should == 1
+    proc{@pool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
+    @pool.instance_variable_get(:@conns).length.should == 0
+  end
 end

data/spec/sequel_core/core_sql_spec.rb

@@ -259,12 +259,18 @@ context "Symbol#*" do
     :xyz.*(3).to_s(@ds).should == '(xyz * 3)'
     :abc.*(5).to_s(@ds).should == '(abc * 5)'
   end
+
+  specify "should support qualified symbols if no argument" do
+    :xyz__abc.*.to_s(@ds).should == 'xyz.abc.*'
+  end
+
 end
 
 context "Symbol" do
   before do
     @ds = Sequel::Dataset.new(nil)
     @ds.quote_identifiers = true
+    @ds.upcase_identifiers = true
   end
 
   specify "#identifier should format an identifier" do
@@ -276,11 +282,12 @@ context "Symbol" do
   end
 
   specify "should be able to qualify an identifier" do
-    @ds.literal(:xyz.identifier.qualify(:xyz__abc)).should == '"XYZ__ABC"."XYZ"'
+    @ds.literal(:xyz.identifier.qualify(:xyz__abc)).should == '"XYZ"."ABC"."XYZ"'
   end
 
   specify "should be able to specify a schema.table.column" do
-    @ds.literal(:column.qualify(:table__name.qualify(:schema))).should == '"SCHEMA"."TABLE__NAME"."COLUMN"'
+    @ds.literal(:column.qualify(:table.qualify(:schema))).should == '"SCHEMA"."TABLE"."COLUMN"'
+    @ds.literal(:column.qualify(:table__name.identifier.qualify(:schema))).should == '"SCHEMA"."TABLE__NAME"."COLUMN"'
   end
 end
 

data/spec/sequel_core/database_spec.rb

@@ -6,6 +6,7 @@ context "A new Database" do
   end
   teardown do
     Sequel.quote_identifiers = false
+    Sequel.upcase_identifiers = false
   end
   
   specify "should receive options" do
@@ -39,15 +40,41 @@ context "A new Database" do
     cc.should == 1234
   end
 
-  specify "should respect the :quote_identifiers and :single_threaded options" do
-    db = Sequel::Database.new(:quote_identifiers=>false, :single_threaded=>true)
-    db.quote_identifiers?.should == false
+  specify "should respect the :single_threaded option" do
+    db = Sequel::Database.new(:single_threaded=>true)
     db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
-    db = Sequel::Database.new(:quote_identifiers=>true, :single_threaded=>false)
-    db.quote_identifiers?.should == true
+    db = Sequel::Database.new(:single_threaded=>false)
     db.pool.should be_a_kind_of(Sequel::ConnectionPool)
   end
 
+  specify "should respect the :quote_identifiers option" do
+    db = Sequel::Database.new(:quote_identifiers=>false)
+    db.quote_identifiers?.should == false
+    db = Sequel::Database.new(:quote_identifiers=>true)
+    db.quote_identifiers?.should == true
+  end
+
+  specify "should respect the :upcase_identifiers option" do
+    Sequel.upcase_identifiers = false
+    db = Sequel::Database.new(:upcase_identifiers=>false)
+    db.upcase_identifiers?.should == false
+    db.upcase_identifiers = true
+    db.upcase_identifiers?.should == true
+    db = Sequel::Database.new(:upcase_identifiers=>true)
+    db.upcase_identifiers?.should == true
+    db.upcase_identifiers = false
+    db.upcase_identifiers?.should == false
+    Sequel.upcase_identifiers = true
+    db = Sequel::Database.new(:upcase_identifiers=>false)
+    db.upcase_identifiers?.should == false
+    db.upcase_identifiers = true
+    db.upcase_identifiers?.should == true
+    db = Sequel::Database.new(:upcase_identifiers=>true)
+    db.upcase_identifiers?.should == true
+    db.upcase_identifiers = false
+    db.upcase_identifiers?.should == false
+  end
+
   specify "should use the default Sequel.quote_identifiers value" do
     Sequel.quote_identifiers = true
     Sequel::Database.new({}).quote_identifiers?.should == true
@@ -59,6 +86,26 @@ context "A new Database" do
     Sequel::Database.new({}).quote_identifiers?.should == false
   end
 
+  specify "should use the default Sequel.upcase_identifiers value" do
+    Sequel.upcase_identifiers = true
+    Sequel::Database.new({}).upcase_identifiers?.should == true
+    Sequel.upcase_identifiers = false
+    Sequel::Database.new({}).upcase_identifiers?.should == false
+    Sequel::Database.upcase_identifiers = true
+    Sequel::Database.new({}).upcase_identifiers?.should == true
+    Sequel::Database.upcase_identifiers = false
+    Sequel::Database.new({}).upcase_identifiers?.should == false
+  end
+
+  specify "should respect the upcase_indentifiers_default method if Sequel.upcase_identifiers = nil" do
+    Sequel.upcase_identifiers = nil
+    Sequel::Database.new({}).upcase_identifiers?.should == true
+    x = Class.new(Sequel::Database){def upcase_identifiers_default; false end}
+    x.new({}).upcase_identifiers?.should == false
+    y = Class.new(Sequel::Database){def upcase_identifiers_default; true end}
+    y.new({}).upcase_identifiers?.should == true
+  end
+
   specify "should just use a :uri option for jdbc with the full connection string" do
     Sequel::Database.should_receive(:adapter_class).once.with(:jdbc).and_return(Sequel::Database)
     db = Sequel.connect('jdbc:test://host/db_name')
@@ -67,15 +114,20 @@ context "A new Database" do
   end
 end
 
-context "Database#connect" do
-  specify "should raise Sequel::Error::NotImplemented" do
-    proc {Sequel::Database.new.connect}.should raise_error(NotImplementedError)
+context "Database#disconnect" do
+  specify "should call pool.disconnect" do
+    d = Sequel::Database.new
+    p = d.pool
+    a = 1
+    p.meta_def(:disconnect){a += 1}
+    d.disconnect.should == 2
+    a.should == 2
   end
 end
 
-context "Database#disconnect" do
+context "Database#connect" do
   specify "should raise Sequel::Error::NotImplemented" do
-    proc {Sequel::Database.new.disconnect}.should raise_error(NotImplementedError)
+    proc {Sequel::Database.new.connect}.should raise_error(NotImplementedError)
   end
 end
 
@@ -437,14 +489,12 @@ end
 context "Database#table_exists?" do
   setup do
     @db = DummyDatabase.new
-    @db.stub!(:tables).and_return([:a, :b])
+    @db.instance_variable_set(:@schemas, {:a=>[]})
     @db2 = DummyDatabase.new
   end
   
-  specify "should use Database#tables if available" do
+  specify "should use schema information if available" do
     @db.table_exists?(:a).should be_true
-    @db.table_exists?(:b).should be_true
-    @db.table_exists?(:c).should be_false
   end
   
   specify "should otherwise try to select the first record from the table's dataset" do

data/spec/sequel_core/dataset_spec.rb

@@ -191,6 +191,26 @@ context "A dataset with multiple tables in its FROM clause" do
   end
 end
 
+context "Dataset#exists" do
+  setup do
+    @ds1 = Sequel::Dataset.new(nil).from(:test)
+    @ds2 = @ds1.filter(:price < 100)
+    @ds3 = @ds1.filter(:price > 50)
+  end
+  
+  specify "should work in filters" do
+    @ds1.filter(@ds2.exists).sql.should ==
+      'SELECT * FROM test WHERE (EXISTS (SELECT * FROM test WHERE (price < 100)))'
+    @ds1.filter(@ds2.exists & @ds3.exists).sql.should ==
+      'SELECT * FROM test WHERE (EXISTS (SELECT * FROM test WHERE (price < 100)) AND EXISTS (SELECT * FROM test WHERE (price > 50)))'
+  end
+
+  specify "should work in select" do
+    @ds1.select(@ds2.exists.as(:a), @ds3.exists.as(:b)).sql.should ==
+      'SELECT EXISTS (SELECT * FROM test WHERE (price < 100)) AS a, EXISTS (SELECT * FROM test WHERE (price > 50)) AS b FROM test'
+  end
+end
+
 context "Dataset#where" do
   setup do
     @dataset = Sequel::Dataset.new(nil).from(:test)
@@ -1309,6 +1329,23 @@ context "Dataset#join_table" do
       'SELECT * FROM "foo" AS "f" INNER JOIN "bar" ON ("bar"."id" = "f"."bar_id")'
   end
   
+  specify "should support implicit schemas in from table symbols" do
+    @d.from(:s__t).join(:u__v, {:id => :player_id}).sql.should ==
+      'SELECT * FROM "s"."t" INNER JOIN "u"."v" ON ("u"."v"."id" = "s"."t"."player_id")'
+  end
+
+  specify "should support implicit aliases in from table symbols" do
+    @d.from(:t___z).join(:v___y, {:id => :player_id}).sql.should ==
+      'SELECT * FROM "t" AS "z" INNER JOIN "v" AS "y" ON ("y"."id" = "z"."player_id")'
+    @d.from(:s__t___z).join(:u__v___y, {:id => :player_id}).sql.should ==
+      'SELECT * FROM "s"."t" AS "z" INNER JOIN "u"."v" AS "y" ON ("y"."id" = "z"."player_id")'
+  end
+  
+  specify "should support AliasedExpressions" do
+    @d.from(:s.as(:t)).join(:u.as(:v), {:id => :player_id}).sql.should ==
+      'SELECT * FROM "s" AS "t" INNER JOIN "u" AS "v" ON ("v"."id" = "t"."player_id")'
+  end
+
   specify "should support the :implicit_qualifier option" do
     @d.from('stats').join('players', {:id => :player_id}, :implicit_qualifier=>:p).sql.should ==
       'SELECT * FROM "stats" INNER JOIN "players" ON ("players"."id" = "p"."player_id")'
@@ -2874,14 +2911,12 @@ end
 context "Dataset#table_exists?" do
   setup do
     @db = DummyMummyDatabase.new
-    @db.stub!(:tables).and_return([:a, :b])
+    @db.instance_variable_set(:@schemas, {:a=>[]})
     @db2 = DummyMummyDatabase.new
   end
   
-  specify "should use Database#tables if available" do
+  specify "should use the database schema if available" do
     @db[:a].table_exists?.should be_true
-    @db[:b].table_exists?.should be_true
-    @db[:c].table_exists?.should be_false
   end
   
   specify "should otherwise try to select the first record from the table's dataset" do
@@ -3053,10 +3088,14 @@ context "Dataset prepared statements and bound variables " do
     def @db.execute(sql, opts={})
       @sqls << sql
     end
-    @ds = @db[:items]
-    def @ds.fetch_rows(sql, &block)
-      execute(sql)
+    def @db.dataset
+      ds = super()
+      def ds.fetch_rows(sql, &block)
+        execute(sql)
+      end
+      ds
     end
+    @ds = @db[:items]
   end
   
   specify "#call should take a type and bind hash and interpolate it" do
@@ -3097,6 +3136,36 @@ context "Dataset prepared statements and bound variables " do
     @ds.filter(:num=>:$n).prepare(:select, :sn).inspect.should == \
       '<Sequel::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = $n)">'
   end
+    
+  specify "should handle literal strings" do
+    @ds.filter("num = ?", :$n).call(:select, :n=>1)
+    @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)']
+  end
+    
+  specify "should handle datasets using static sql and placeholders" do
+    @db["SELECT * FROM items WHERE (num = ?)", :$n].call(:select, :n=>1)
+    @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)']
+  end
+    
+  specify "should handle subselects" do
+    @ds.filter(:$b).filter(:num=>@ds.select(:num).filter(:num=>:$n)).filter(:$c).call(:select, :n=>1, :b=>0, :c=>2)
+    @db.sqls.should == ['SELECT * FROM items WHERE ((0 AND (num IN (SELECT num FROM items WHERE (num = 1)))) AND 2)']
+  end
+    
+  specify "should handle subselects in subselects" do
+    @ds.filter(:$b).filter(:num=>@ds.select(:num).filter(:num=>@ds.select(:num).filter(:num=>:$n))).call(:select, :n=>1, :b=>0)
+    @db.sqls.should == ['SELECT * FROM items WHERE (0 AND (num IN (SELECT num FROM items WHERE (num IN (SELECT num FROM items WHERE (num = 1))))))']
+  end
+    
+  specify "should handle subselects with literal strings" do
+    @ds.filter(:$b).filter(:num=>@ds.select(:num).filter("num = ?", :$n)).call(:select, :n=>1, :b=>0)
+    @db.sqls.should == ['SELECT * FROM items WHERE (0 AND (num IN (SELECT num FROM items WHERE (num = 1))))']
+  end
+    
+  specify "should handle subselects with static sql and placeholders" do
+    @ds.filter(:$b).filter(:num=>@db["SELECT num FROM items WHERE (num = ?)", :$n]).call(:select, :n=>1, :b=>0)
+    @db.sqls.should == ['SELECT * FROM items WHERE (0 AND (num IN (SELECT num FROM items WHERE (num = 1))))']
+  end
 end
 
 context Sequel::Dataset::UnnumberedArgumentMapper do
@@ -3233,3 +3302,32 @@ context "Sequel::Dataset#each" do
     end
   end
 end
+
+context Sequel::Dataset::UnsupportedIntersectExcept do
+  before do
+    @ds = Sequel::Dataset.new(nil).from(:items)
+    @ds2 = Sequel::Dataset.new(nil).from(:i)
+    @ds.extend(Sequel::Dataset::UnsupportedIntersectExcept)
+  end
+
+  specify "should raise an error if INTERSECT or EXCEPT is USED" do
+    @ds.union(@ds2).sql.should == 'SELECT * FROM items UNION SELECT * FROM i'
+    proc{@ds.intersect(@ds2)}.should raise_error(Sequel::Error)
+    proc{@ds.except(@ds2)}.should raise_error(Sequel::Error)
+  end
+end
+
+context Sequel::Dataset::UnsupportedIntersectExceptAll do
+  before do
+    @ds = Sequel::Dataset.new(nil).from(:items)
+    @ds2 = Sequel::Dataset.new(nil).from(:i)
+    @ds.extend(Sequel::Dataset::UnsupportedIntersectExceptAll)
+  end
+
+  specify "should raise an error if INTERSECT or EXCEPT is USED" do
+    @ds.intersect(@ds2).sql.should == 'SELECT * FROM items INTERSECT SELECT * FROM i'
+    @ds.except(@ds2).sql.should == 'SELECT * FROM items EXCEPT SELECT * FROM i'
+    proc{@ds.intersect(@ds2, true)}.should raise_error(Sequel::Error)
+    proc{@ds.except(@ds2, true)}.should raise_error(Sequel::Error)
+  end
+end