sequel 3.1.0 → 3.2.0

data/spec/adapters/oracle_spec.rb

@@ -3,6 +3,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 unless defined?(ORACLE_DB)
   ORACLE_DB = Sequel.connect('oracle://hr:hr@localhost/XE')
 end
+INTEGRATION_DB = ORACLE_DB unless defined?(INTEGRATION_DB)
 
 if ORACLE_DB.table_exists?(:items)
   ORACLE_DB.drop_table :items

data/spec/adapters/postgres_spec.rb

@@ -4,6 +4,7 @@ unless defined?(POSTGRES_DB)
   POSTGRES_URL = 'postgres://postgres:postgres@localhost:5432/reality_spec' unless defined? POSTGRES_URL
   POSTGRES_DB = Sequel.connect(ENV['SEQUEL_PG_SPEC_DB']||POSTGRES_URL)
 end
+INTEGRATION_DB = POSTGRES_DB unless defined?(INTEGRATION_DB)
 
 def POSTGRES_DB.sqls
   (@sqls ||= [])
@@ -43,12 +44,12 @@ context "A PostgreSQL database" do
 
   specify "should correctly parse the schema" do
     @db.schema(:test3, :reload=>true).should == [
-      [:value, {:type=>:integer, :allow_null=>true, :default=>nil, :db_type=>"integer", :primary_key=>false}],
-      [:time, {:type=>:datetime, :allow_null=>true, :default=>nil, :db_type=>"timestamp without time zone", :primary_key=>false}]
+      [:value, {:type=>:integer, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"integer", :primary_key=>false}],
+      [:time, {:type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp without time zone", :primary_key=>false}]
     ]
     @db.schema(:test4, :reload=>true).should == [
-      [:name, {:type=>:string, :allow_null=>true, :default=>nil, :db_type=>"character varying(20)", :primary_key=>false}],
-      [:value, {:type=>:blob, :allow_null=>true, :default=>nil, :db_type=>"bytea", :primary_key=>false}]
+      [:name, {:type=>:string, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"character varying(20)", :primary_key=>false}],
+      [:value, {:type=>:blob, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"bytea", :primary_key=>false}]
     ]
   end
 end
@@ -144,6 +145,14 @@ context "A PostgreSQL dataset with a timestamp field" do
   end
 end
 
+context "PostgreSQL's EXPLAIN and ANALYZE" do
+  specify "should not raise errors" do
+    @d = POSTGRES_DB[:test3]
+    proc{@d.explain}.should_not raise_error
+    proc{@d.analyze}.should_not raise_error
+  end
+end
+
 context "A PostgreSQL database" do
   before do
     @db = POSTGRES_DB
@@ -208,6 +217,15 @@ context "A PostgreSQL database" do
     @db.reset_primary_key_sequence(:posts).should == nil
   end
   
+  
+  specify "should support opclass specification" do
+    @db.create_table(:posts){text :title; text :body; integer :user_id; index(:user_id, :opclass => :int4_ops, :type => :btree)}
+    @db.sqls.should == [
+    "CREATE TABLE posts (title text, body text, user_id integer)",
+    "CREATE INDEX posts_user_id_index ON posts USING btree (user_id int4_ops)"
+    ]
+  end
+
   specify "should support fulltext indexes and searching" do
     @db.create_table(:posts){text :title; text :body; full_text_index [:title, :body]; full_text_index :title, :language => 'french'}
     @db.sqls.should == [
@@ -515,6 +533,36 @@ if POSTGRES_DB.server_version >= 80300
   end
 end
 
+if POSTGRES_DB.dataset.supports_window_functions?
+  context "Postgres::Dataset named windows" do
+    before do
+      @db = POSTGRES_DB
+      @db.create_table!(:i1){Integer :id; Integer :group_id; Integer :amount}
+      @ds = @db[:i1].order(:id)
+      @ds.insert(:id=>1, :group_id=>1, :amount=>1)
+      @ds.insert(:id=>2, :group_id=>1, :amount=>10)
+      @ds.insert(:id=>3, :group_id=>1, :amount=>100)
+      @ds.insert(:id=>4, :group_id=>2, :amount=>1000)
+      @ds.insert(:id=>5, :group_id=>2, :amount=>10000)
+      @ds.insert(:id=>6, :group_id=>2, :amount=>100000)
+    end
+    after do
+      @db.drop_table(:i1)
+    end
+    
+    specify "should give correct results for window functions" do
+      @ds.window(:win, :partition=>:group_id, :order=>:id).select(:id){sum(:over, :args=>amount, :window=>win){}}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.window(:win, :partition=>:group_id).select(:id){sum(:over, :args=>amount, :window=>win, :order=>id){}}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.window(:win, {}).select(:id){sum(:over, :args=>amount, :window=>:win, :order=>id){}}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
+      @ds.window(:win, :partition=>:group_id).select(:id){sum(:over, :args=>amount, :window=>:win, :order=>id, :frame=>:all){}}.all.should ==
+        [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
+    end
+  end
+end
+
 context "Postgres::Database functions, languages, and triggers" do
   before do
     @d = POSTGRES_DB

data/spec/adapters/spec_helper.rb

@@ -1,10 +1,10 @@
 require 'rubygems'
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
-  require 'sequel/core'
+  require 'sequel'
   Sequel.quote_identifiers = false
 end
 begin
-  require File.join(File.dirname(__FILE__), '../spec_config.rb')
+  require File.join(File.dirname(File.dirname(__FILE__)), 'spec_config.rb')
 rescue LoadError
 end

data/spec/adapters/sqlite_spec.rb

@@ -4,6 +4,7 @@ unless defined?(SQLITE_DB)
   SQLITE_URL = 'sqlite:/' unless defined? SQLITE_URL
   SQLITE_DB = Sequel.connect(ENV['SEQUEL_SQLITE_SPEC_DB']||SQLITE_URL)
 end
+INTEGRATION_DB = SQLITE_DB unless defined?(INTEGRATION_DB)
 
 context "An SQLite database" do
   before do
@@ -94,7 +95,7 @@ context "An SQLite database" do
   
   specify "should correctly parse the schema" do
     @db.create_table!(:time2) {timestamp :t}
-    @db.schema(:time2, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :default=>nil, :db_type=>"timestamp", :primary_key=>false}]]
+    @db.schema(:time2, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp", :primary_key=>false}]]
   end
 end
 

data/spec/core/connection_pool_spec.rb

@@ -20,6 +20,22 @@ context "An empty ConnectionPool" do
   end
 end
 
+context "ConnectionPool options" do
+  specify "should support string option values" do
+    cpool = Sequel::ConnectionPool.new({:max_connections=>'5', :pool_timeout=>'3', :pool_sleep_time=>'0.01'})
+    cpool.max_size.should == 5
+    cpool.instance_variable_get(:@timeout).should == 3
+    cpool.instance_variable_get(:@sleep_time).should == 0.01
+  end
+
+  specify "should raise an error unless size is positive" do
+    lambda{Sequel::ConnectionPool.new(:max_connections=>0)}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.new(:max_connections=>-10)}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.new(:max_connections=>'-10')}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.new(:max_connections=>'0')}.should raise_error(Sequel::Error)
+  end
+end
+
 context "A connection pool handling connections" do
   before do
     @max_size = 2

data/spec/core/database_spec.rb

@@ -39,8 +39,16 @@ context "A new Database" do
   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(:single_threaded=>'t')
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+    db = Sequel::Database.new(:single_threaded=>'1')
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
     db = Sequel::Database.new(:single_threaded=>false)
     db.pool.should be_a_kind_of(Sequel::ConnectionPool)
+    db = Sequel::Database.new(:single_threaded=>'f')
+    db.pool.should be_a_kind_of(Sequel::ConnectionPool)
+    db = Sequel::Database.new(:single_threaded=>'0')
+    db.pool.should be_a_kind_of(Sequel::ConnectionPool)
   end
 
   specify "should respect the :quote_identifiers option" do
@@ -640,6 +648,106 @@ context "Database#transaction" do
   end
 end
 
+context "Database#transaction with savepoints" do
+  before do
+    @db = Dummy3Database.new
+    @db.meta_def(:supports_savepoints?){true}
+    @db.pool.connection_proc = proc {Dummy3Database::DummyConnection.new(@db)}
+  end
+  
+  specify "should wrap the supplied block with BEGIN + COMMIT statements" do
+    @db.transaction {@db.execute 'DROP TABLE test;'}
+    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+  end
+  
+  specify "should use savepoints if given the :savepoint option" do
+    @db.transaction{@db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test;'}}
+    @db.sql.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+  end
+  
+  specify "should not use a savepoints if no transaction is in progress" do
+    @db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test;'}
+    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+  end
+  
+  specify "should reuse the current transaction if no :savepoint option is given" do
+    @db.transaction{@db.transaction{@db.execute 'DROP TABLE test;'}}
+    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+  end
+  
+  specify "should handle returning inside of the block by committing" do
+    def @db.ret_commit
+      transaction do
+        execute 'DROP TABLE test;'
+        return
+        execute 'DROP TABLE test2;';
+      end
+    end
+    @db.ret_commit
+    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+  end
+  
+  specify "should handle returning inside of a savepoint by committing" do
+    def @db.ret_commit
+      transaction do
+        transaction(:savepoint=>true) do
+          execute 'DROP TABLE test;'
+          return
+          execute 'DROP TABLE test2;';
+        end
+      end
+    end
+    @db.ret_commit
+    @db.sql.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+  end
+  
+  specify "should issue ROLLBACK if an exception is raised, and re-raise" do
+    @db.transaction {@db.execute 'DROP TABLE test'; raise RuntimeError} rescue nil
+    @db.sql.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
+    
+    proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
+  end
+  
+  specify "should issue ROLLBACK SAVEPOINT if an exception is raised inside a savepoint, and re-raise" do
+    @db.transaction{@db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test'; raise RuntimeError}} rescue nil
+    @db.sql.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test', 'ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
+    
+    proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
+  end
+  
+  specify "should issue ROLLBACK if Sequel::Rollback is called in the transaction" do
+    @db.transaction do
+      @db.drop_table(:a)
+      raise Sequel::Rollback
+      @db.drop_table(:b)
+    end
+    
+    @db.sql.should == ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
+  end
+  
+  specify "should issue ROLLBACK SAVEPOINT if Sequel::Rollback is called in a savepoint" do
+    @db.transaction do
+      @db.transaction(:savepoint=>true) do
+        @db.drop_table(:a)
+        raise Sequel::Rollback
+      end
+      @db.drop_table(:b)
+    end
+    
+    @db.sql.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE a', 'ROLLBACK TO SAVEPOINT autopoint_1', 'DROP TABLE b', 'COMMIT']
+  end
+  
+  specify "should raise database errors when commiting a transaction as Sequel::DatabaseError" do
+    @db.meta_def(:commit_transaction){raise ArgumentError}
+    lambda{@db.transaction{}}.should raise_error(ArgumentError)
+    lambda{@db.transaction{@db.transaction(:savepoint=>true){}}}.should raise_error(ArgumentError)
+
+    @db.meta_def(:database_error_classes){[ArgumentError]}
+    lambda{@db.transaction{}}.should raise_error(Sequel::DatabaseError)
+    lambda{@db.transaction{@db.transaction(:savepoint=>true){}}}.should raise_error(Sequel::DatabaseError)
+  end
+end
+
 context "A Database adapter with a scheme" do
   before do
     class CCC < Sequel::Database
@@ -740,6 +848,13 @@ context "A Database adapter with a scheme" do
 
 end
 
+context "Sequel::Database.connect" do
+  specify "should raise an Error if not given a String or Hash" do
+    proc{Sequel::Database.connect(nil)}.should raise_error(Sequel::Error)
+    proc{Sequel::Database.connect(Object.new)}.should raise_error(Sequel::Error)
+  end
+end
+
 context "An unknown database scheme" do
   specify "should raise an error in Sequel::Database.connect" do
     proc {Sequel::Database.connect('ddd://localhost/db')}.should raise_error(Sequel::AdapterNotFound)
@@ -1181,3 +1296,62 @@ context "Database#metadata_dataset" do
     ds.send(:output_identifier, 'A').should == :a
   end
 end
+
+context "Database#column_schema_to_ruby_default" do
+  specify "should handle converting many default formats" do
+    db = Sequel::Database.new
+    m = db.method(:column_schema_to_ruby_default)
+    p = lambda{|d,t| m.call(d,t)}
+    p[nil, :integer].should == nil
+    p['1', :integer].should == 1
+    p['-1', :integer].should == -1
+    p['1.0', :float].should == 1.0
+    p['-1.0', :float].should == -1.0
+    p['1.0', :decimal].should == BigDecimal.new('1.0')
+    p['-1.0', :decimal].should == BigDecimal.new('-1.0')
+    p['1', :boolean].should == true
+    p['0', :boolean].should == false
+    p['true', :boolean].should == true
+    p['false', :boolean].should == false
+    p["'t'", :boolean].should == true
+    p["'f'", :boolean].should == false
+    p["'a'", :string].should == 'a'
+    p["'a'", :blob].should == 'a'.to_sequel_blob
+    p["'a'", :blob].should be_a_kind_of(Sequel::SQL::Blob)
+    p["''", :string].should == ''
+    p["'\\a''b'", :string].should == "\\a'b"
+    p["'NULL'", :string].should == "NULL"
+    p["'2009-10-29'", :date].should == Date.new(2009,10,29)
+    p["CURRENT_TIMESTAMP", :date].should == nil
+    p["today()", :date].should == nil
+    p["'2009-10-29T10:20:30-07:00'", :datetime].should == DateTime.parse('2009-10-29T10:20:30-07:00')
+    p["'2009-10-29 10:20:30'", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
+    p["'10:20:30'", :time].should == Time.parse('10:20:30')
+    p["NaN", :float].should == nil
+
+    db.meta_def(:database_type){:postgres}
+    p["''::text", :string].should == ""
+    p["'\\a''b'::character varying", :string].should == "\\a'b"
+    p["'a'::bpchar", :string].should == "a"
+    p["(-1)", :integer].should == -1
+    p["(-1.0)", :float].should == -1.0
+    p['(-1.0)', :decimal].should == BigDecimal.new('-1.0')
+    p["'a'::bytea", :blob].should == 'a'.to_sequel_blob
+    p["'a'::bytea", :blob].should be_a_kind_of(Sequel::SQL::Blob)
+    p["'2009-10-29'::date", :date].should == Date.new(2009,10,29)
+    p["'2009-10-29 10:20:30.241343'::timestamp without time zone", :datetime].should == DateTime.parse('2009-10-29 10:20:30.241343')
+    p["'10:20:30'::time without time zone", :time].should == Time.parse('10:20:30')
+
+    db.meta_def(:database_type){:mysql}
+    p["\\a'b", :string].should == "\\a'b"
+    p["a", :string].should == "a"
+    p["NULL", :string].should == "NULL"
+    p["-1", :float].should == -1.0
+    p['-1', :decimal].should == BigDecimal.new('-1.0')
+    p["2009-10-29", :date].should == Date.new(2009,10,29)
+    p["2009-10-29 10:20:30", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
+    p["10:20:30", :time].should == Time.parse('10:20:30')
+    p["CURRENT_DATE", :date].should == nil
+    p["CURRENT_TIMESTAMP", :datetime].should == nil
+  end
+end

data/spec/core/dataset_spec.rb

@@ -758,6 +758,22 @@ context "Dataset#literal" do
     s = d.strftime("'%Y-%m-%d'")
     @dataset.literal(d).should == s
   end
+
+  specify "should literalize Time, DateTime, Date properly if SQL standard format is required" do
+    @dataset.meta_def(:requires_sql_standard_datetimes?){true}
+
+    t = Time.now
+    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+    @dataset.literal(t).should == s
+
+    t = DateTime.now
+    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+    @dataset.literal(t).should == s
+
+    d = Date.today
+    s = d.strftime("DATE '%Y-%m-%d'")
+    @dataset.literal(d).should == s
+  end
   
   specify "should not modify literal strings" do
     @dataset.literal('col1 + 2'.lit).should == 'col1 + 2'
@@ -1249,6 +1265,12 @@ context "Dataset#distinct" do
     @dataset.distinct.sql.should == 'SELECT DISTINCT name FROM test'
   end
   
+  specify "should raise an error if columns given and distinct on not supported" do
+    @dataset.meta_def(:supports_distinct_on?){false}
+    proc{@dataset.distinct}.should_not raise_error
+    proc{@dataset.distinct(:a)}.should raise_error(Sequel::InvalidOperation)
+  end
+  
   specify "should accept an expression list" do
     @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'
@@ -1505,6 +1527,9 @@ context "Dataset#join_table" do
 
     @d.join_table(:left_outer, ds, :item_id => :id).sql.should ==
       'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories WHERE (active IS TRUE)) AS "t1" ON ("t1"."item_id" = "items"."id")'
+
+    @d.from_self.join_table(:left_outer, ds, :item_id => :id).sql.should ==
+      'SELECT * FROM (SELECT * FROM "items") AS "t1" LEFT OUTER JOIN (SELECT * FROM categories WHERE (active IS TRUE)) AS "t2" ON ("t2"."item_id" = "t1"."id")'
   end
   
   specify "should support joining datasets and aliasing the join" do
@@ -1861,6 +1886,8 @@ context "Dataset compound operations" do
       "SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)) AS t1"
     @b.union(@a, true).sql.should == \
       "SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @b.union(@a, :all=>true).sql.should == \
+      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1"
   end
 
   specify "should support INTERSECT and INTERSECT ALL" do
@@ -1868,6 +1895,8 @@ context "Dataset compound operations" do
       "SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT SELECT * FROM b WHERE (z = 2)) AS t1"
     @b.intersect(@a, true).sql.should == \
       "SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @b.intersect(@a, :all=>true).sql.should == \
+      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
   end
 
   specify "should support EXCEPT and EXCEPT ALL" do
@@ -1875,6 +1904,40 @@ context "Dataset compound operations" do
       "SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)) AS t1"
     @b.except(@a, true).sql.should == \
       "SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @b.except(@a, :all=>true).sql.should == \
+      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+  end
+    
+  specify "should support :from_self=>false option to not wrap the compound in a SELECT * FROM (...)" do
+    @b.union(@a, :from_self=>false).sql.should == \
+      "SELECT * FROM b WHERE (z = 2) UNION SELECT * FROM a WHERE (z = 1)"
+    @b.intersect(@a, :from_self=>false).sql.should == \
+      "SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1)"
+    @b.except(@a, :from_self=>false).sql.should == \
+      "SELECT * FROM b WHERE (z = 2) EXCEPT SELECT * FROM a WHERE (z = 1)"
+      
+    @b.union(@a, :from_self=>false, :all=>true).sql.should == \
+      "SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)"
+    @b.intersect(@a, :from_self=>false, :all=>true).sql.should == \
+      "SELECT * FROM b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)"
+    @b.except(@a, :from_self=>false, :all=>true).sql.should == \
+      "SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)"
+  end
+
+  specify "should raise an InvalidOperation if INTERSECT or EXCEPT is used and they are not supported" do
+    @a.meta_def(:supports_intersect_except?){false}
+    proc{@a.intersect(@b)}.should raise_error(Sequel::InvalidOperation)
+    proc{@a.intersect(@b, true)}.should raise_error(Sequel::InvalidOperation)
+    proc{@a.except(@b)}.should raise_error(Sequel::InvalidOperation)
+    proc{@a.except(@b, true)}.should raise_error(Sequel::InvalidOperation)
+  end
+    
+  specify "should raise an InvalidOperation if INTERSECT ALL or EXCEPT ALL is used and they are not supported" do
+    @a.meta_def(:supports_intersect_except_all?){false}
+    proc{@a.intersect(@b)}.should_not raise_error
+    proc{@a.intersect(@b, true)}.should raise_error(Sequel::InvalidOperation)
+    proc{@a.except(@b)}.should_not raise_error
+    proc{@a.except(@b, true)}.should raise_error(Sequel::InvalidOperation)
   end
     
   specify "should handle chained compound operations" do
@@ -2449,29 +2512,6 @@ class DummyMummyDatabase < Sequel::Database
   end
 end
 
-context "Dataset#table_exists?" do
-  before do
-    @db = DummyMummyDatabase.new
-  end
-  
-  specify "should otherwise try to select the first record from the table's dataset" do
-    @db[:a].table_exists?.should be_false
-    @db[:b].table_exists?.should be_true
-  end
-  
-  specify "should raise Sequel::Error if dataset references more than one table" do
-    proc {@db.from(:a, :b).table_exists?}.should raise_error(Sequel::Error)
-  end
-
-  specify "should raise Sequel::Error if dataset is from a subquery" do
-    proc {@db.from(@db[:a]).table_exists?}.should raise_error(Sequel::Error)
-  end
-
-  specify "should raise Sequel::Error if dataset has fixed sql" do
-    proc {@db['select * from blah'].table_exists?}.should raise_error(Sequel::Error)
-  end
-end
-
 context "Dataset#inspect" do
   before do
     @ds = Sequel::Dataset.new(nil).from(:blah)
@@ -2782,8 +2822,18 @@ context "Sequel::Dataset #set_overrides" do
   end
 end
 
+context "Sequel::Dataset#qualify" do
+  specify "should qualify to the given table" do
+    MockDatabase.new[:t].filter{a<b}.qualify(:e).sql.should == 'SELECT e.* FROM t WHERE (e.a < e.b)'
+  end
+
+  specify "should qualify to the first source if no table if given" do
+    MockDatabase.new[:t].filter{a<b}.qualify.sql.should == 'SELECT t.* FROM t WHERE (t.a < t.b)'
+  end
+end
+
 context "Sequel::Dataset#qualify_to" do
-  specify "should qualify_to the first source" do
+  specify "should qualify to the given table" do
     MockDatabase.new[:t].filter{a<b}.qualify_to(:e).sql.should == 'SELECT e.* FROM t WHERE (e.a < e.b)'
   end
 end
@@ -2861,8 +2911,53 @@ context "Sequel::Dataset#qualify_to_first_source" do
     @ds.filter{a.sql_subscript(b,3)}.qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE t.a[t.b, 3]'
   end
 
+  specify "should handle SQL::PlaceholderLiteralStrings" do
+    @ds.filter('? > ?', :a, 1).qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE (t.a > 1)'
+  end
+
+  specify "should handle SQL::WindowFunctions" do
+    @ds.meta_def(:supports_window_functions?){true}
+    @ds.select{sum(:over, :args=>:a, :partition=>:b, :order=>:c){}}.qualify_to_first_source.sql.should == 'SELECT sum(t.a) OVER (PARTITION BY t.b ORDER BY t.c) FROM t'
+  end
+
   specify "should handle all other objects by returning them unchanged" do
-    @ds.select("a").filter{a(3)}.filter('blah').order('true'.lit).group('?'.lit(:a)).having(false).qualify_to_first_source.sql.should == \
-      "SELECT 'a' FROM t WHERE (a(3) AND (blah)) GROUP BY a HAVING 'f' ORDER BY true"
+    @ds.select("a").filter{a(3)}.filter('blah').order('true'.lit).group('a > ?'.lit(1)).having(false).qualify_to_first_source.sql.should == \
+      "SELECT 'a' FROM t WHERE (a(3) AND (blah)) GROUP BY a > 1 HAVING 'f' ORDER BY true"
   end
 end
+
+context "Sequel::Dataset #with and #with_recursive" do
+  before do
+    @db = MockDatabase.new
+    @ds = @db[:t]
+  end
+  
+  specify "#with should take a name and dataset and use a WITH clause" do
+    @ds.with(:t, @db[:x]).sql.should == 'WITH t AS (SELECT * FROM x) SELECT * FROM t'
+  end
+
+  specify "#with_recursive should take a name, nonrecursive dataset, and recursive dataset, and use a WITH clause" do
+    @ds.with_recursive(:t, @db[:x], @db[:t]).sql.should == 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
+  end
+  
+  specify "#with and #with_recursive should add to existing WITH clause if called multiple times" do
+    @ds.with(:t, @db[:x]).with(:j, @db[:y]).sql.should == 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y) SELECT * FROM t'
+    @ds.with_recursive(:t, @db[:x], @db[:t]).with_recursive(:j, @db[:y], @db[:j]).sql.should == 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t), j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t'
+    @ds.with(:t, @db[:x]).with_recursive(:j, @db[:y], @db[:j]).sql.should == 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t'
+  end
+  
+  specify "#with and #with_recursive should take an :args option" do
+    @ds.with(:t, @db[:x], :args=>[:b]).sql.should == 'WITH t(b) AS (SELECT * FROM x) SELECT * FROM t'
+    @ds.with_recursive(:t, @db[:x], @db[:t], :args=>[:b, :c]).sql.should == 'WITH t(b, c) AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
+  end
+  
+  specify "#with_recursive should take an :union_all=>false option" do
+    @ds.with_recursive(:t, @db[:x], @db[:t], :union_all=>false).sql.should == 'WITH t AS (SELECT * FROM x UNION SELECT * FROM t) SELECT * FROM t'
+  end
+
+  specify "#with and #with_recursive should raise an error unless the dataset supports CTEs" do
+    @ds.meta_def(:supports_cte?){false}
+    proc{@ds.with(:t, @db[:x], :args=>[:b])}.should raise_error(Sequel::Error)
+    proc{@ds.with_recursive(:t, @db[:x], @db[:t], :args=>[:b, :c])}.should raise_error(Sequel::Error)
+  end
+end