sequel 3.0.0 → 3.1.0

data/spec/adapters/firebird_spec.rb

@@ -5,6 +5,15 @@ unless defined?(FIREBIRD_DB)
   FIREBIRD_DB = Sequel.connect(ENV['SEQUEL_FB_SPEC_DB']||FIREBIRD_URL)
 end
 
+def FIREBIRD_DB.sqls
+  (@sqls ||= [])
+end
+logger = Object.new
+def logger.method_missing(m, msg)
+  FIREBIRD_DB.sqls.push(msg)
+end
+FIREBIRD_DB.logger = logger
+
 FIREBIRD_DB.create_table! :test do
   varchar :name,  :size => 50
   integer :val,   :index => true
@@ -30,7 +39,7 @@ FIREBIRD_DB.create_table! :test6 do
   blob :val
   String :val2
   varchar :val3, :size=>200
-  text :val4
+  String :val4, :text=>true
 end
 
 context "A Firebird database" do
@@ -54,6 +63,7 @@ context "A Firebird dataset" do
   before do
     @d = FIREBIRD_DB[:test]
     @d.delete # remove all records
+    @d.quote_identifiers = true
   end
 
   specify "should return the correct record count" do
@@ -236,81 +246,74 @@ end
 context "A Firebird database" do
   before do
     @db = FIREBIRD_DB
+    @db.drop_table(:posts) rescue nil
+    @db.sqls.clear
   end
 
   specify "should allow us to name the sequences" do
-    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
-      primary_key :id, :sequence_name => "seq_test"
-    end
-    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
+    @db.create_table(:posts){primary_key :id, :sequence_name => "seq_test"}
+    @db.sqls.should == [
+      "DROP SEQUENCE SEQ_TEST",
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_TEST",
       "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
-    ], "DROP SEQUENCE SEQ_TEST" ]
+    ]
   end
 
   specify "should allow us to set the starting position for the sequences" do
-    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
-      primary_key :id, :sequence_start_position => 999
-    end
-    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
+    @db.create_table(:posts){primary_key :id, :sequence_start_position => 999}
+    @db.sqls.should == [
+      "DROP SEQUENCE SEQ_POSTS_ID",
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_POSTS_ID",
       "ALTER SEQUENCE SEQ_POSTS_ID RESTART WITH 999",
       "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
-    ], "DROP SEQUENCE SEQ_POSTS_ID" ]
+    ]
   end
 
   specify "should allow us to name and set the starting position for the sequences" do
-    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
-      primary_key :id, :sequence_name => "seq_test", :sequence_start_position => 999
-    end
-    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
+    @db.create_table(:posts){primary_key :id, :sequence_name => "seq_test", :sequence_start_position => 999}
+    @db.sqls.should == [
+      "DROP SEQUENCE SEQ_TEST",
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_TEST",
       "ALTER SEQUENCE SEQ_TEST RESTART WITH 999",
       "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
-    ], "DROP SEQUENCE SEQ_TEST" ]
+    ]
   end
 
   specify "should allow us to name the triggers" do
-    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
-      primary_key :id, :trigger_name => "trig_test"
-    end
-    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
+    @db.create_table(:posts){primary_key :id, :trigger_name => "trig_test"}
+    @db.sqls.should == [
+      "DROP SEQUENCE SEQ_POSTS_ID",
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_POSTS_ID",
       "          CREATE TRIGGER TRIG_TEST for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
-    ], "DROP SEQUENCE SEQ_POSTS_ID" ]
+    ]
   end
 
   specify "should allow us to not create the sequence" do
-    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
-      primary_key :id, :create_sequence => false
-    end
-    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
+    @db.create_table(:posts){primary_key :id, :create_sequence => false}
+    @db.sqls.should == [
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
-    ], nil]
+    ]
   end
 
   specify "should allow us to not create the trigger" do
-    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
-      primary_key :id, :create_trigger => false
-    end
-    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
+    @db.create_table(:posts){primary_key :id, :create_trigger => false}
+    @db.sqls.should == [
+      "DROP SEQUENCE SEQ_POSTS_ID",
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_POSTS_ID",
-    ], "DROP SEQUENCE SEQ_POSTS_ID"]
+    ]
   end
 
   specify "should allow us to not create either the sequence nor the trigger" do
-    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
-      primary_key :id, :create_sequence => false, :create_trigger => false
-    end
-    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
+    @db.create_table(:posts){primary_key :id, :create_sequence => false, :create_trigger => false}
+    @db.sqls.should == [
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )"
-    ], nil]
+    ]
   end
 
   specify "should support column operations" do

data/spec/adapters/mysql_spec.rb

@@ -29,15 +29,9 @@ MYSQL_DB.drop_table(:items) rescue nil
 MYSQL_DB.drop_table(:dolls) rescue nil
 MYSQL_DB.drop_table(:booltest) rescue nil
 
-if MYSQL_DB.class.adapter_scheme == :do
-  SQL_BEGIN = 'Transaction.begin'
-  SQL_ROLLBACK = 'Transaction.rollback'
-  SQL_COMMIT = 'Transaction.commit'
-else
-  SQL_BEGIN = 'BEGIN'
-  SQL_ROLLBACK = 'ROLLBACK'
-  SQL_COMMIT = 'COMMIT'
-end
+SQL_BEGIN = 'BEGIN'
+SQL_ROLLBACK = 'ROLLBACK'
+SQL_COMMIT = 'COMMIT'
 
 context "MySQL", '#create_table' do
   before do
@@ -57,6 +51,16 @@ context "MySQL", '#create_table' do
     @db.create_table(:tmp_dolls, :temp => true, :engine => 'MyISAM', :charset => 'latin2'){text :name}
     @db.sqls.should == ["CREATE TEMPORARY TABLE tmp_dolls (name text) ENGINE=MyISAM DEFAULT CHARSET=latin2"]
   end
+  
+  specify "should not use a default for a String :text=>true type" do
+    @db.create_table(:dolls){String :name, :text=>true, :default=>'blah'}
+    @db.sqls.should == ["CREATE TABLE dolls (name text)"]
+  end
+  
+  specify "should not use a default for a File type" do
+    @db.create_table(:dolls){File :name, :default=>'blah'}
+    @db.sqls.should == ["CREATE TABLE dolls (name blob)"]
+  end
 end
 
 context "A MySQL database" do
@@ -577,6 +581,12 @@ context "A MySQL database" do
       "CREATE UNIQUE INDEX posts_id_index USING btree ON posts (id)"
     ]
   end
+
+  specify "should not dump partial indexes" do
+    @db.create_table(:posts){text :id}
+    @db << "CREATE INDEX posts_id_index ON posts (id(10))"
+    @db.indexes(:posts).should == {}
+  end
 end
 
 context "MySQL::Dataset#insert and related methods" do
@@ -710,6 +720,12 @@ context "MySQL::Dataset#insert and related methods" do
     ]
   end
   
+  specify "#insert_ignore should add the IGNORE keyword for single inserts" do
+    @d.insert_ignore.insert(:name => 'ghi')
+    MYSQL_DB.sqls.should == ["INSERT IGNORE INTO items (name) VALUES ('ghi')"]
+    @d.all.should == [{:name => 'ghi', :value => nil}]
+  end
+  
   specify "#on_duplicate_key_update should add the ON DUPLICATE KEY UPDATE and ALL columns when no args given" do
     @d.on_duplicate_key_update.import([:name,:value], 
       [['abc', 1], ['def',2]]

data/spec/adapters/postgres_spec.rb

@@ -121,30 +121,6 @@ context "A PostgreSQL dataset" do
     @d.reverse_order(:name.desc, :test).sql.should == \
       'SELECT * FROM "test" ORDER BY "name" ASC, "test" DESC'
   end
-  
-  specify "should support nested transactions through savepoints using the savepoint option" do
-    POSTGRES_DB.transaction do
-      @d << {:name => '1'}
-      POSTGRES_DB.transaction(:savepoint=>true) do
-        @d << {:name => '2'}
-        POSTGRES_DB.transaction do
-          @d << {:name => '3'}
-          raise Sequel::Rollback
-        end
-      end
-      @d << {:name => '4'}
-      POSTGRES_DB.transaction do
-        @d << {:name => '6'}
-        POSTGRES_DB.transaction(:savepoint=>true) do
-          @d << {:name => '7'}
-          raise Sequel::Rollback
-        end
-      end
-      @d << {:name => '5'}
-    end
-
-    @d.order(:name).map(:name).should == %w{1 4 5 6}
-  end
 
   specify "should support regexps" do
     @d << {:name => 'abc', :value => 1}
@@ -227,6 +203,11 @@ context "A PostgreSQL database" do
     @db[:posts].order(:a).map(:a).should == [1, 2, 10, 20, 21]
   end
   
+  specify "should not raise an error if attempting to resetting the primary key sequence for a table without a primary key" do
+    @db.create_table(:posts){Integer :a}
+    @db.reset_primary_key_sequence(:posts).should == nil
+  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 == [
@@ -340,6 +321,12 @@ context "Postgres::Dataset#insert" do
     @db.drop_table(:test5) rescue nil
   end
 
+  specify "should work with static SQL" do
+    @ds.with_sql('INSERT INTO test5 (value) VALUES (10)').insert.should == nil
+    @db['INSERT INTO test5 (value) VALUES (20)'].insert.should == nil
+    @ds.all.should == [{:xid=>1, :value=>10}, {:xid=>2, :value=>20}]
+  end
+
   specify "should work regardless of how it is used" do
     @ds.insert(:value=>10).should == 1
     @ds.disable_insert_returning.insert(:value=>20).should == 2

data/spec/core/database_spec.rb

@@ -188,6 +188,12 @@ context "Database#disconnect" do
   end
 end
 
+context "Sequel.extension" do
+  specify "should attempt to load the given extension" do
+    proc{Sequel.extension :blah}.should raise_error(LoadError)
+  end
+end
+
 context "Database#connect" do
   specify "should raise NotImplementedError" do
     proc {Sequel::Database.new.connect}.should raise_error(NotImplementedError)
@@ -551,19 +557,10 @@ context "Database#rename_table" do
 end
 
 context "Database#table_exists?" do
-  before do
-    @db = DummyDatabase.new
-    @db.instance_variable_set(:@schemas, {:a=>[]})
-    @db2 = DummyDatabase.new
-  end
-  
-  specify "should use schema information if available" do
-    @db.table_exists?(:a).should be_true
-  end
-  
-  specify "should otherwise try to select the first record from the table's dataset" do
-    @db2.table_exists?(:a).should be_false
-    @db2.table_exists?(:b).should be_true
+  specify "should try to select the first record from the table's dataset" do
+    db2 = DummyDatabase.new
+    db2.table_exists?(:a).should be_false
+    db2.table_exists?(:b).should be_true
   end
 end
 
@@ -617,6 +614,14 @@ context "Database#transaction" do
     @db.sql.should == ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
   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)
+
+    @db.meta_def(:database_error_classes){[ArgumentError]}
+    lambda{@db.transaction{}}.should raise_error(Sequel::DatabaseError)
+  end
+  
   specify "should be re-entrant" do
     stop = false
     cc = nil
@@ -1091,6 +1096,10 @@ context "Database#raise_error" do
   specify "should convert the exception to a DatabaseError if opts[:classes] if not present" do
     proc{MockDatabase.new.send(:raise_error, Interrupt.new(''))}.should raise_error(Sequel::DatabaseError)
   end
+  
+  specify "should convert the exception to a DatabaseDisconnectError if opts[:disconnect] is true" do
+    proc{MockDatabase.new.send(:raise_error, Interrupt.new(''), :disconnect=>true)}.should raise_error(Sequel::DatabaseDisconnectError)
+  end
 end
 
 context "Database#typecast_value" do
@@ -1140,3 +1149,35 @@ context "Database#schema_autoincrementing_primary_key?" do
     m.call(:primary_key=>false).should == false
   end
 end
+
+context "Database#supports_savepoints?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_savepoints?.should == false
+  end
+end
+
+context "Database#input_identifier_meth" do
+  specify "should be the input_identifer method of a default dataset for this database" do
+    db = Sequel::Database.new
+    db.send(:input_identifier_meth).call(:a).should == 'a'
+    db.identifier_input_method = :upcase
+    db.send(:input_identifier_meth).call(:a).should == 'A'
+  end
+end
+
+context "Database#output_identifier_meth" do
+  specify "should be the output_identifer method of a default dataset for this database" do
+    db = Sequel::Database.new
+    db.send(:output_identifier_meth).call('A').should == :A
+    db.identifier_output_method = :downcase
+    db.send(:output_identifier_meth).call('A').should == :a
+  end
+end
+
+context "Database#metadata_dataset" do
+  specify "should be a dataset with the default settings for identifier_input_method and identifier_output_method" do
+    ds = Sequel::Database.new.send(:metadata_dataset)
+    ds.literal(:a).should == 'A'
+    ds.send(:output_identifier, 'A').should == :a
+  end
+end

data/spec/core/dataset_spec.rb

@@ -1858,46 +1858,63 @@ context "Dataset compound operations" do
   
   specify "should support UNION and UNION ALL" do
     @a.union(@b).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)"
+      "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 b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)"
+      "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
     @a.intersect(@b).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) INTERSECT SELECT * FROM b WHERE (z = 2)"
+      "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 b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)"
+      "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
     @a.except(@b).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)"
+      "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 b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)"
+      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
   end
     
   specify "should handle chained compound operations" do
     @a.union(@b).union(@a, true).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)"
+      "SELECT * FROM (SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)) AS t1 UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1"
     @a.intersect(@b, true).intersect(@a).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1)"
+      "SELECT * FROM (SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM b WHERE (z = 2)) AS t1 INTERSECT SELECT * FROM a WHERE (z = 1)) AS t1"
     @a.except(@b).except(@a, true).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)"
-    @a.union(@b, true).intersect(@a).except(@b, true).union(@a).intersect(@b, true).except(@a).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) UNION ALL SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1) EXCEPT ALL SELECT * FROM b WHERE (z = 2) UNION SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM b WHERE (z = 2) EXCEPT SELECT * FROM a WHERE (z = 1)"
+      "SELECT * FROM (SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)) AS t1 EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
   end
   
   specify "should use a subselect when using a compound operation with a dataset that already has a compound operation" do
     @a.union(@b.union(@a, true)).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1))"
+      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1) AS t1"
     @a.intersect(@b.intersect(@a), true).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1))"
+      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1)) AS t1) AS t1"
     @a.except(@b.except(@a, true)).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1))"
-    @a.union(@b.intersect(@a.except(@b, true)), true).union(@a.intersect(@b.except(@a), true)).sql.should == \
-      "SELECT * FROM a WHERE (z = 1) UNION ALL SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT ALL SELECT * FROM b WHERE (z = 2))) UNION SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT SELECT * FROM a WHERE (z = 1)))"
+      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1) AS t1"
   end
+
+  specify "should order and limit properly when using UNION, INTERSECT, or EXCEPT" do
+    @dataset = Sequel::Dataset.new(nil).from(:test)
+    @dataset.union(@dataset).limit(2).sql.should ==
+      "SELECT * FROM (SELECT * FROM test UNION SELECT * FROM test) AS t1 LIMIT 2"
+    @dataset.limit(2).intersect(@dataset).sql.should == 
+      "SELECT * FROM (SELECT * FROM (SELECT * FROM test LIMIT 2) AS t1 INTERSECT SELECT * FROM test) AS t1"
+    @dataset.except(@dataset.limit(2)).sql.should == 
+      "SELECT * FROM (SELECT * FROM test EXCEPT SELECT * FROM (SELECT * FROM test LIMIT 2) AS t1) AS t1"
+
+    @dataset.union(@dataset).order(:num).sql.should ==
+      "SELECT * FROM (SELECT * FROM test UNION SELECT * FROM test) AS t1 ORDER BY num"
+    @dataset.order(:num).intersect(@dataset).sql.should == 
+      "SELECT * FROM (SELECT * FROM (SELECT * FROM test ORDER BY num) AS t1 INTERSECT SELECT * FROM test) AS t1"
+    @dataset.except(@dataset.order(:num)).sql.should == 
+      "SELECT * FROM (SELECT * FROM test EXCEPT SELECT * FROM (SELECT * FROM test ORDER BY num) AS t1) AS t1"
+
+    @dataset.limit(2).order(:a).union(@dataset.limit(3).order(:b)).order(:c).limit(4).sql.should ==
+      "SELECT * FROM (SELECT * FROM (SELECT * FROM test ORDER BY a LIMIT 2) AS t1 UNION SELECT * FROM (SELECT * FROM test ORDER BY b LIMIT 3) AS t1) AS t1 ORDER BY c LIMIT 4"
+  end
+
 end
 
 context "Dataset#[]" do
@@ -2404,6 +2421,10 @@ context "Dataset#insert_sql" do
   specify "should accept array subscript references" do
     @ds.insert_sql((:day.sql_subscript(1)) => 'd').should == "INSERT INTO items (day[1]) VALUES ('d')"
   end
+
+  specify "should raise an Error if the dataset has no sources" do
+    proc{Sequel::Database.new.dataset.insert_sql}.should raise_error(Sequel::Error)
+  end
 end
 
 class DummyMummyDataset < Sequel::Dataset
@@ -2431,17 +2452,11 @@ end
 context "Dataset#table_exists?" do
   before do
     @db = DummyMummyDatabase.new
-    @db.instance_variable_set(:@schemas, {:a=>[]})
-    @db2 = DummyMummyDatabase.new
-  end
-  
-  specify "should use the database schema if available" do
-    @db[:a].table_exists?.should be_true
   end
   
   specify "should otherwise try to select the first record from the table's dataset" do
-    @db2[:a].table_exists?.should be_false
-    @db2[:b].table_exists?.should be_true
+    @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
@@ -2669,17 +2684,35 @@ context Sequel::Dataset::UnnumberedArgumentMapper do
     def @ds.execute(sql, opts={}, &block)
       @db.execute(sql, {:arguments=>bind_arguments}.merge(opts))
     end
-    @ps = @ds.prepare(:select, :sn)
-    @ps.extend(Sequel::Dataset::UnnumberedArgumentMapper)
+    def @ds.execute_dui(*args, &block)
+      execute(*args, &block)
+    end
+    def @ds.execute_insert(*args, &block)
+      execute(*args, &block)
+    end
+    @ps = []
+    @ps << @ds.prepare(:select, :s)
+    @ps << @ds.prepare(:all, :a)
+    @ps << @ds.prepare(:first, :f)
+    @ps << @ds.prepare(:delete, :d)
+    @ps << @ds.prepare(:insert, :i, :num=>:$n)
+    @ps << @ds.prepare(:update, :u, :num=>:$n)
+    @ps.each{|p| p.extend(Sequel::Dataset::UnnumberedArgumentMapper)}
   end
 
   specify "#inspect should show the actual SQL submitted to the database" do
-    @ps.inspect.should == '<Sequel::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = ?)">'
+    @ps.first.inspect.should == '<Sequel::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = ?)">'
   end
   
   specify "should submitted the SQL to the database with placeholders and bind variables" do
-    @ps.call(:n=>1)
-    @db.sqls.should == [["SELECT * FROM items WHERE (num = ?)", 1]]
+    @ps.each{|p| p.call(:n=>1)}
+    @db.sqls.should == [["SELECT * FROM items WHERE (num = ?)", 1],
+      ["SELECT * FROM items WHERE (num = ?)", 1],
+      ["SELECT * FROM items WHERE (num = ?) LIMIT 1", 1],
+      ["DELETE FROM items WHERE (num = ?)", 1],
+      ["INSERT INTO items (num) VALUES (?)", 1],
+      ["UPDATE items SET num = ? WHERE (num = ?)", 1, 1],
+      ]
   end
 end
 
@@ -2748,3 +2781,88 @@ context "Sequel::Dataset #set_overrides" do
     @ds.set_overrides(:x=>2).update_sql.should == "UPDATE items SET x = 1"
   end
 end
+
+context "Sequel::Dataset#qualify_to" do
+  specify "should qualify_to the first source" do
+    MockDatabase.new[:t].filter{a<b}.qualify_to(:e).sql.should == 'SELECT e.* FROM t WHERE (e.a < e.b)'
+  end
+end
+
+context "Sequel::Dataset#qualify_to_first_source" do
+  before do
+    @ds = MockDatabase.new[:t]
+  end
+
+  specify "should qualify_to the first source" do
+    @ds.qualify_to_first_source.sql.should == 'SELECT t.* FROM t'
+    @ds.should_receive(:qualify_to).with(:t).once
+    @ds.qualify_to_first_source
+  end
+
+  specify "should handle the select, order, where, having, and group options/clauses" do
+    @ds.select(:a).filter(:a=>1).order(:a).group(:a).having(:a).qualify_to_first_source.sql.should == \
+      'SELECT t.a FROM t WHERE (t.a = 1) GROUP BY t.a HAVING t.a ORDER BY t.a'
+  end
+
+  specify "should handle the select using a table.* if all columns are currently selected" do
+    @ds.filter(:a=>1).order(:a).group(:a).having(:a).qualify_to_first_source.sql.should == \
+      'SELECT t.* FROM t WHERE (t.a = 1) GROUP BY t.a HAVING t.a ORDER BY t.a'
+  end
+
+  specify "should handle hashes in select option" do
+    @ds.select(:a=>:b).qualify_to_first_source.sql.should == 'SELECT t.a AS b FROM t'
+  end
+
+  specify "should handle symbols" do
+    @ds.select(:a, :b__c, :d___e, :f__g___h).qualify_to_first_source.sql.should == 'SELECT t.a, b.c, t.d AS e, f.g AS h FROM t'
+  end
+
+  specify "should handle arrays" do
+    @ds.filter(:a=>[:b, :c]).qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE (t.a IN (t.b, t.c))'
+  end
+
+  specify "should handle hashes" do
+    @ds.select({:b=>{:c=>1}}.case(false)).qualify_to_first_source.sql.should == "SELECT (CASE WHEN t.b THEN (t.c = 1) ELSE 'f' END) FROM t"
+  end
+
+  specify "should handle SQL::Identifiers" do
+    @ds.select{a}.qualify_to_first_source.sql.should == 'SELECT t.a FROM t'
+  end
+
+  specify "should handle SQL::OrderedExpressions" do
+    @ds.order(:a.desc, :b.asc).qualify_to_first_source.sql.should == 'SELECT t.* FROM t ORDER BY t.a DESC, t.b ASC'
+  end
+
+  specify "should handle SQL::AliasedExpressions" do
+    @ds.select(:a.as(:b)).qualify_to_first_source.sql.should == 'SELECT t.a AS b FROM t'
+  end
+
+  specify "should handle SQL::CaseExpressions" do
+    @ds.filter{{a=>b}.case(c, d)}.qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE (CASE t.d WHEN t.a THEN t.b ELSE t.c END)'
+  end
+
+  specify "should handle SQL:Casts" do
+    @ds.filter{a.cast(:boolean)}.qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE CAST(t.a AS boolean)'
+  end
+
+  specify "should handle SQL::Functions" do
+    @ds.filter{a(b, 1)}.qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE a(t.b, 1)'
+  end
+
+  specify "should handle SQL::ComplexExpressions" do
+    @ds.filter{(a+b)<(c-3)}.qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE ((t.a + t.b) < (t.c - 3))'
+  end
+
+  specify "should handle SQL::SQLArrays" do
+    @ds.filter(:a=>[:b, :c].sql_array).qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE (t.a IN (t.b, t.c))'
+  end
+
+  specify "should handle SQL::Subscripts" 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 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"
+  end
+end