sequel 3.21.0 → 3.41.0

data/spec/core/schema_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe "DB#create_table" do
   before do
-    @db = SchemaDummyDatabase.new
+    @db = Sequel.mock
   end
   
   specify "should accept the table name" do
@@ -13,14 +13,14 @@ describe "DB#create_table" do
   specify "should accept the table name in multiple formats" do
     @db.create_table(:cats__cats) {}
     @db.create_table("cats__cats1") {}
-    @db.create_table(:cats__cats2.identifier) {}
-    @db.create_table(:cats.qualify(:cats3)) {}
+    @db.create_table(Sequel.identifier(:cats__cats2)) {}
+    @db.create_table(Sequel.qualify(:cats3, :cats)) {}
     @db.sqls.should == ['CREATE TABLE cats.cats ()', 'CREATE TABLE cats__cats1 ()', 'CREATE TABLE cats__cats2 ()', 'CREATE TABLE cats3.cats ()']
   end
 
   specify "should raise an error if the table name argument is not valid" do
     proc{@db.create_table(1) {}}.should raise_error(Sequel::Error)
-    proc{@db.create_table(:cats.as(:c)) {}}.should raise_error(Sequel::Error)
+    proc{@db.create_table(Sequel.as(:cats, :c)) {}}.should raise_error(Sequel::Error)
   end
 
   specify "should remove cached schema entry" do
@@ -88,13 +88,11 @@ describe "DB#create_table" do
     end
     @db.sqls.should == ['CREATE TABLE cats (id integer PRIMARY KEY AUTOINCREMENT)']
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       primary_key :id, :serial, :auto_increment => false
     end
     @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY)']
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       primary_key :id, :type => :serial, :auto_increment => false
     end
@@ -154,7 +152,6 @@ describe "DB#create_table" do
       varchar :name
     end
     @db.sqls.should == ["CREATE TABLE cats (name varchar(255))"]
-    @db.sqls.clear
     @db.create_table(:cats) do
       varchar :name, :size => 51
     end
@@ -199,7 +196,6 @@ describe "DB#create_table" do
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects(id))"]
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :key => :zzz
     end
@@ -212,32 +208,30 @@ describe "DB#create_table" do
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE RESTRICT)"]
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :cascade
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE CASCADE)"]
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :no_action
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE NO ACTION)"]
-    @db.sqls.clear
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :set_null
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET NULL)"]
-    @db.sqls.clear
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :set_default
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET DEFAULT)"]
-    @db.sqls.clear
+
+    @db.create_table(:cats) do
+      foreign_key :project_id, :table => :projects, :on_delete => 'NO ACTION FOO'
+    end
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE NO ACTION FOO)"]
   end
 
   specify "should accept foreign keys with ON UPDATE clause" do
@@ -246,32 +240,30 @@ describe "DB#create_table" do
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON UPDATE RESTRICT)"]
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_update => :cascade
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON UPDATE CASCADE)"]
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_update => :no_action
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON UPDATE NO ACTION)"]
-    @db.sqls.clear
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_update => :set_null
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON UPDATE SET NULL)"]
-    @db.sqls.clear
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_update => :set_default
     end
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON UPDATE SET DEFAULT)"]
-    @db.sqls.clear
+
+    @db.create_table(:cats) do
+      foreign_key :project_id, :table => :projects, :on_update => 'SET DEFAULT FOO'
+    end
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON UPDATE SET DEFAULT FOO)"]
   end
   
   specify "should accept foreign keys with deferrable option" do
@@ -281,6 +273,13 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects DEFERRABLE INITIALLY DEFERRED)"]
   end
 
+  specify "should accept collation" do
+    @db.create_table(:cats) do
+      varchar :name, :collate => :utf8_bin
+    end
+    @db.sqls.should == ["CREATE TABLE cats (name varchar(255) COLLATE utf8_bin)"]
+  end
+
   specify "should accept inline index definition" do
     @db.create_table(:cats) do
       integer :id, :index => true
@@ -288,6 +287,13 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)"]
   end
   
+  specify "should accept inline index definition with a hash of options" do
+    @db.create_table(:cats) do
+      integer :id, :index => {:unique=>true}
+    end
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_index ON cats (id)"]
+  end
+  
   specify "should accept inline index definition for foreign keys" do
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :cascade, :index => true
@@ -296,6 +302,14 @@ describe "DB#create_table" do
       "CREATE INDEX cats_project_id_index ON cats (project_id)"]
   end
   
+  specify "should accept inline index definition for foreign keys with a hash of options" do
+    @db.create_table(:cats) do
+      foreign_key :project_id, :table => :projects, :on_delete => :cascade, :index => {:unique=>true}
+    end
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE CASCADE)",
+      "CREATE UNIQUE INDEX cats_project_id_index ON cats (project_id)"]
+  end
+  
   specify "should accept index definitions" do
     @db.create_table(:cats) do
       integer :id
@@ -361,7 +375,6 @@ describe "DB#create_table" do
     @db.meta_def(:execute_ddl){|*a| raise Sequel::DatabaseError if /blah/.match(a.first); super(*a)}
     lambda{@db.create_table(:cats){Integer :id; index :blah; index :id}}.should raise_error(Sequel::DatabaseError)
     @db.sqls.should == ['CREATE TABLE cats (id integer)']
-    @db.sqls.clear
     lambda{@db.create_table(:cats, :ignore_index_errors=>true){Integer :id; index :blah; index :id}}.should_not raise_error(Sequel::DatabaseError)
     @db.sqls.should == ['CREATE TABLE cats (id integer)', 'CREATE INDEX cats_id_index ON cats (id)']
   end
@@ -378,7 +391,7 @@ describe "DB#create_table" do
   specify "should accept functional indexes" do
     @db.create_table(:cats) do
       integer :id
-      index :lower.sql_function(:name)
+      index Sequel.function(:lower, :name)
     end
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_lower_name__index ON cats (lower(name))"]
   end
@@ -386,7 +399,7 @@ describe "DB#create_table" do
   specify "should accept indexes with identifiers" do
     @db.create_table(:cats) do
       integer :id
-      index :lower__name.identifier
+      index Sequel.identifier(:lower__name)
     end
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_lower__name_index ON cats (lower__name)"]
   end
@@ -418,7 +431,7 @@ describe "DB#create_table" do
   specify "should accept unnamed constraint definitions with blocks" do
     @db.create_table(:cats) do
       integer :score
-      check {(:x.sql_number > 0) & (:y.sql_number < 1)}
+      check{(x.sql_number > 0) & (y.sql_number < 1)}
     end
     @db.sqls.should == ["CREATE TABLE cats (score integer, CHECK ((x > 0) AND (y < 1)))"]
   end
@@ -447,7 +460,7 @@ describe "DB#create_table" do
 
   specify "should accept named constraint definitions with block" do
     @db.create_table(:cats) do
-      constraint(:blah_blah) {(:x.sql_number > 0) & (:y.sql_number < 1)}
+      constraint(:blah_blah){(x.sql_number > 0) & (y.sql_number < 1)}
     end
     @db.sqls.should == ["CREATE TABLE cats (CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1)))"]
   end
@@ -499,7 +512,6 @@ describe "DB#create_table" do
       foreign_key [:a, :b], :abc, :key => [:real_a, :real_b]
     end
     @db.sqls.should == ["CREATE TABLE cats (a integer, b integer, FOREIGN KEY (a, b) REFERENCES abc(real_a, real_b))"]
-    @db.sqls.clear
 
     @db.create_table(:cats) do
       integer :a
@@ -517,7 +529,6 @@ describe "DB#create_table" do
     end
     @db.sqls.should == ["CREATE TABLE cats (a integer, b integer, FOREIGN KEY (a, b) REFERENCES abc ON DELETE CASCADE)"]
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       integer :a
       integer :b
@@ -525,7 +536,6 @@ describe "DB#create_table" do
     end
     @db.sqls.should == ["CREATE TABLE cats (a integer, b integer, FOREIGN KEY (a, b) REFERENCES abc ON UPDATE NO ACTION)"]
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       integer :a
       integer :b
@@ -533,7 +543,6 @@ describe "DB#create_table" do
     end
     @db.sqls.should == ["CREATE TABLE cats (a integer, b integer, FOREIGN KEY (a, b) REFERENCES abc ON DELETE RESTRICT ON UPDATE SET DEFAULT)"]
 
-    @db.sqls.clear
     @db.create_table(:cats) do
       integer :a
       integer :b
@@ -541,28 +550,49 @@ describe "DB#create_table" do
     end
     @db.sqls.should == ["CREATE TABLE cats (a integer, b integer, FOREIGN KEY (a, b) REFERENCES abc(x, y) ON DELETE SET NULL ON UPDATE SET NULL)"]
   end
+
+  specify "should accept an :as option to create a table from the results of a dataset" do
+    @db.create_table(:cats, :as=>@db[:a])
+    @db.sqls.should == ['CREATE TABLE cats AS SELECT * FROM a']
+  end
+
+  specify "should accept an :as option to create a table from a SELECT string" do
+    @db.create_table(:cats, :as=>'SELECT * FROM a')
+    @db.sqls.should == ['CREATE TABLE cats AS SELECT * FROM a']
+  end
+
+  specify "should raise an Error if both a block and an :as argument are given" do
+    proc{@db.create_table(:cats, :as=>@db[:a]){}}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "DB#create_table!" do
   before do
-    @db = SchemaDummyDatabase.new
+    @db = Sequel.mock
   end
   
-  specify "should drop the table and then create it" do
-    @db.create_table!(:cats) {}
+  specify "should create the table if it does not exist" do
+    @db.meta_def(:table_exists?){|a| false}
+    @db.create_table!(:cats){|*a|}
+    @db.sqls.should == ['CREATE TABLE cats ()']
+  end
+  
+  specify "should drop the table before creating it if it already exists" do
+    @db.meta_def(:table_exists?){|a| true}
+    @db.create_table!(:cats){|*a|}
     @db.sqls.should == ['DROP TABLE cats', 'CREATE TABLE cats ()']
   end
 end
 
 describe "DB#create_table?" do
   before do
-    @db = SchemaDummyDatabase.new
+    @db = Sequel.mock
   end
   
   specify "should not create the table if the table already exists" do
     @db.meta_def(:table_exists?){|a| true}
     @db.create_table?(:cats){|*a|}
-    @db.sqls.should == nil
+    @db.sqls.should == []
   end
   
   specify "should create the table if the table doesn't already exist" do
@@ -570,38 +600,191 @@ describe "DB#create_table?" do
     @db.create_table?(:cats){|*a|}
     @db.sqls.should == ['CREATE TABLE cats ()']
   end
+  
+  specify "should use IF NOT EXISTS if the database supports that" do
+    @db.meta_def(:supports_create_table_if_not_exists?){true}
+    @db.create_table?(:cats){|*a|}
+    @db.sqls.should == ['CREATE TABLE IF NOT EXISTS cats ()']
+  end
+end
+
+describe "DB#create_join_table" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should take a hash with foreign keys and table name values" do
+    @db.create_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.sqls.should == ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
+  end
+  
+  specify "should be able to have values be a hash of options" do
+    @db.create_join_table(:cat_id=>{:table=>:cats, :null=>true}, :dog_id=>{:table=>:dogs, :default=>0})
+    @db.sqls.should == ['CREATE TABLE cats_dogs (cat_id integer NULL REFERENCES cats, dog_id integer DEFAULT 0 NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
+  end
+  
+  specify "should be able to pass a second hash of table options" do
+    @db.create_join_table({:cat_id=>:cats, :dog_id=>:dogs}, :temp=>true)
+    @db.sqls.should == ['CREATE TEMPORARY TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
+  end
+  
+  specify "should recognize :name option in table options" do
+    @db.create_join_table({:cat_id=>:cats, :dog_id=>:dogs}, :name=>:f)
+    @db.sqls.should == ['CREATE TABLE f (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX f_dog_id_cat_id_index ON f (dog_id, cat_id)']
+  end
+  
+  specify "should recognize :index_options option in table options" do
+    @db.create_join_table({:cat_id=>:cats, :dog_id=>:dogs}, :index_options=>{:name=>:foo_index})
+    @db.sqls.should == ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX foo_index ON cats_dogs (dog_id, cat_id)']
+  end
+  
+  specify "should recognize :no_index option in table options" do
+    @db.create_join_table({:cat_id=>:cats, :dog_id=>:dogs}, :no_index=>true)
+    @db.sqls.should == ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))']
+  end
+  
+  specify "should recognize :no_primary_key option in table options" do
+    @db.create_join_table({:cat_id=>:cats, :dog_id=>:dogs}, :no_primary_key=>true)
+    @db.sqls.should == ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs)', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
+  end
+  
+  specify "should raise an error if the hash doesn't have 2 entries with table names" do
+    proc{@db.create_join_table({})}.should raise_error(Sequel::Error)
+    proc{@db.create_join_table({:cat_id=>:cats})}.should raise_error(Sequel::Error)
+    proc{@db.create_join_table({:cat_id=>:cats, :human_id=>:humans, :dog_id=>:dog})}.should raise_error(Sequel::Error)
+    proc{@db.create_join_table({:cat_id=>:cats, :dog_id=>{}})}.should raise_error(Sequel::Error)
+  end
+end
+  
+describe "DB#drop_join_table" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should take a hash with foreign keys and table name values and drop the table" do
+    @db.drop_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.sqls.should == ['DROP TABLE cats_dogs']
+  end
+  
+  specify "should be able to have values be a hash of options" do
+    @db.drop_join_table(:cat_id=>{:table=>:cats, :null=>true}, :dog_id=>{:table=>:dogs, :default=>0})
+    @db.sqls.should == ['DROP TABLE cats_dogs']
+  end
+
+  specify "should respect a second hash of table options" do
+    @db.drop_join_table({:cat_id=>:cats, :dog_id=>:dogs}, :cascade=>true)
+    @db.sqls.should == ['DROP TABLE cats_dogs CASCADE']
+  end
+
+  specify "should respect :name option for table name" do
+    @db.drop_join_table({:cat_id=>:cats, :dog_id=>:dogs}, :name=>:f)
+    @db.sqls.should == ['DROP TABLE f']
+  end
+  
+  specify "should raise an error if the hash doesn't have 2 entries with table names" do
+    proc{@db.drop_join_table({})}.should raise_error(Sequel::Error)
+    proc{@db.drop_join_table({:cat_id=>:cats})}.should raise_error(Sequel::Error)
+    proc{@db.drop_join_table({:cat_id=>:cats, :human_id=>:humans, :dog_id=>:dog})}.should raise_error(Sequel::Error)
+    proc{@db.drop_join_table({:cat_id=>:cats, :dog_id=>{}})}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "DB#drop_table" do
   before do
-    @db = SchemaDummyDatabase.new
+    @db = Sequel.mock
   end
 
   specify "should generate a DROP TABLE statement" do
     @db.drop_table :cats
     @db.sqls.should == ['DROP TABLE cats']
   end
+
+  specify "should drop multiple tables at once" do
+    @db.drop_table :cats, :dogs
+    @db.sqls.should == ['DROP TABLE cats', 'DROP TABLE dogs']
+  end
+
+  specify "should take an options hash and support the :cascade option" do
+    @db.drop_table :cats, :dogs, :cascade=>true
+    @db.sqls.should == ['DROP TABLE cats CASCADE', 'DROP TABLE dogs CASCADE']
+  end
+end
+
+describe "DB#drop_table?" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should drop the table if it exists" do
+    @db.meta_def(:table_exists?){|a| true}
+    @db.drop_table?(:cats)
+    @db.sqls.should == ["DROP TABLE cats"]
+  end
+  
+  specify "should do nothing if the table does not exist" do
+    @db.meta_def(:table_exists?){|a| false}
+    @db.drop_table?(:cats)
+    @db.sqls.should == []
+  end
+  
+  specify "should operate on multiple tables at once" do
+    @db.meta_def(:table_exists?){|a| a == :cats}
+    @db.drop_table? :cats, :dogs
+    @db.sqls.should == ['DROP TABLE cats']
+  end
+
+  specify "should take an options hash and support the :cascade option" do
+    @db.meta_def(:table_exists?){|a| true}
+    @db.drop_table? :cats, :dogs, :cascade=>true
+    @db.sqls.should == ['DROP TABLE cats CASCADE', 'DROP TABLE dogs CASCADE']
+  end
+
+  specify "should use IF NOT EXISTS if the database supports that" do
+    @db.meta_def(:supports_drop_table_if_exists?){true}
+    @db.drop_table? :cats, :dogs
+    @db.sqls.should == ['DROP TABLE IF EXISTS cats', 'DROP TABLE IF EXISTS dogs']
+  end
+
+  specify "should use IF NOT EXISTS with CASCADE if the database supports that" do
+    @db.meta_def(:supports_drop_table_if_exists?){true}
+    @db.drop_table? :cats, :dogs, :cascade=>true
+    @db.sqls.should == ['DROP TABLE IF EXISTS cats CASCADE', 'DROP TABLE IF EXISTS dogs CASCADE']
+  end
 end
 
 describe "DB#alter_table" do
   before do
-    @db = SchemaDummyDatabase.new
+    @db = Sequel.mock
   end
   
-  specify "should allow adding not null constraint" do
+  specify "should allow adding not null constraint via set_column_allow_null with false argument" do
     @db.alter_table(:cats) do
       set_column_allow_null :score, false
     end
     @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score SET NOT NULL"]
   end
   
-  specify "should allow droping not null constraint" do
+  specify "should allow removing not null constraint via set_column_allow_null with true argument" do
     @db.alter_table(:cats) do
       set_column_allow_null :score, true
     end
     @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score DROP NOT NULL"]
   end
 
+  specify "should allow adding not null constraint via set_column_not_null" do
+    @db.alter_table(:cats) do
+      set_column_not_null :score
+    end
+    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score SET NOT NULL"]
+  end
+  
+  specify "should allow removing not null constraint via set_column_allow_null without argument" do
+    @db.alter_table(:cats) do
+      set_column_allow_null :score
+    end
+    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score DROP NOT NULL"]
+  end
+
   specify "should support add_column" do
     @db.alter_table(:cats) do
       add_column :score, :integer
@@ -618,7 +801,7 @@ describe "DB#alter_table" do
 
   specify "should support add_constraint with block" do
     @db.alter_table(:cats) do
-      add_constraint(:blah_blah) {(:x.sql_number > 0) & (:y.sql_number < 1)}
+      add_constraint(:blah_blah){(x.sql_number > 0) & (y.sql_number < 1)}
     end
     @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1))"]
   end
@@ -629,7 +812,6 @@ describe "DB#alter_table" do
     end
     @db.sqls.should == ["ALTER TABLE cats ADD UNIQUE (a, b)"]
 
-    @db.sqls.clear
     @db.alter_table(:cats) do
       add_unique_constraint [:a, :b], :name => :ab_uniq
     end
@@ -649,19 +831,16 @@ describe "DB#alter_table" do
     end
     @db.sqls.should == ["ALTER TABLE cats ADD FOREIGN KEY (node_id, prop_id) REFERENCES nodes_props"]
 
-    @db.sqls.clear
     @db.alter_table(:cats) do
       add_foreign_key [:node_id, :prop_id], :nodes_props, :name => :cfk
     end
     @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT cfk FOREIGN KEY (node_id, prop_id) REFERENCES nodes_props"]
 
-    @db.sqls.clear
     @db.alter_table(:cats) do
       add_foreign_key [:node_id, :prop_id], :nodes_props, :key => [:nid, :pid]
     end
     @db.sqls.should == ["ALTER TABLE cats ADD FOREIGN KEY (node_id, prop_id) REFERENCES nodes_props(nid, pid)"]
 
-    @db.sqls.clear
     @db.alter_table(:cats) do
       add_foreign_key [:node_id, :prop_id], :nodes_props, :on_delete => :restrict, :on_update => :cascade
     end
@@ -679,7 +858,7 @@ describe "DB#alter_table" do
     @db.meta_def(:execute_ddl){|*a| raise Sequel::DatabaseError}
     lambda{@db.add_index(:cats, :id)}.should raise_error(Sequel::DatabaseError)
     lambda{@db.add_index(:cats, :id, :ignore_errors=>true)}.should_not raise_error(Sequel::DatabaseError)
-    @db.sqls.should == nil
+    @db.sqls.should == []
   end
 
   specify "should support add_primary_key" do
@@ -695,7 +874,6 @@ describe "DB#alter_table" do
     end
     @db.sqls.should == ["ALTER TABLE cats ADD PRIMARY KEY (id, type)"]
 
-    @db.sqls.clear
     @db.alter_table(:cats) do
       add_primary_key [:id, :type], :name => :cpk
     end
@@ -709,6 +887,13 @@ describe "DB#alter_table" do
     @db.sqls.should == ["ALTER TABLE cats DROP COLUMN score"]
   end
 
+  specify "should support drop_column with :cascade=>true option" do
+    @db.alter_table(:cats) do
+      drop_column :score, :cascade=>true
+    end
+    @db.sqls.should == ["ALTER TABLE cats DROP COLUMN score CASCADE"]
+  end
+
   specify "should support drop_constraint" do
     @db.alter_table(:cats) do
       drop_constraint :valid_score
@@ -716,6 +901,13 @@ describe "DB#alter_table" do
     @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT valid_score"]
   end
 
+  specify "should support drop_constraint with :cascade=>true option" do
+    @db.alter_table(:cats) do
+      drop_constraint :valid_score, :cascade=>true
+    end
+    @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT valid_score CASCADE"]
+  end
+
   specify "should support drop_index" do
     @db.alter_table(:cats) do
       drop_index :name
@@ -761,6 +953,270 @@ describe "DB#alter_table" do
       "ALTER TABLE cats ALTER COLUMN score TYPE varchar(30)",
       "ALTER TABLE cats ALTER COLUMN score TYPE enum('a', 'b')"]
   end
+
+  specify "should combine operations into a single query if the database supports it" do
+    @db.meta_def(:supports_combining_alter_table_ops?){true}
+    @db.alter_table(:cats) do
+      add_column :a, Integer
+      drop_column :b
+      set_column_not_null :c
+      rename_column :d, :e
+      set_column_default :f, 'g'
+      set_column_type :h, Integer
+      add_constraint(:i){a > 1}
+      drop_constraint :j
+    end
+    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN a integer, DROP COLUMN b, ALTER COLUMN c SET NOT NULL, RENAME COLUMN d TO e, ALTER COLUMN f SET DEFAULT 'g', ALTER COLUMN h TYPE integer, ADD CONSTRAINT i CHECK (a > 1), DROP CONSTRAINT j"]
+  end
+  
+  specify "should combine operations into consecutive groups of combinable operations if the database supports combining operations" do
+    @db.meta_def(:supports_combining_alter_table_ops?){true}
+    @db.alter_table(:cats) do
+      add_column :a, Integer
+      drop_column :b
+      set_column_not_null :c
+      rename_column :d, :e
+      add_index :e
+      set_column_default :f, 'g'
+      set_column_type :h, Integer
+      add_constraint(:i){a > 1}
+      drop_constraint :j
+    end
+    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN a integer, DROP COLUMN b, ALTER COLUMN c SET NOT NULL, RENAME COLUMN d TO e",
+      "CREATE INDEX cats_e_index ON cats (e)",
+      "ALTER TABLE cats ALTER COLUMN f SET DEFAULT 'g', ALTER COLUMN h TYPE integer, ADD CONSTRAINT i CHECK (a > 1), DROP CONSTRAINT j"]
+  end
+  
+end
+
+describe "Database#create_table" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.create_table :test do
+      primary_key :id, :integer, :null => false
+      column :name, :text
+      index :name, :unique => true
+    end
+    @db.sqls.should == ['CREATE TABLE test (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
+      'CREATE UNIQUE INDEX test_name_index ON test (name)']
+  end
+  
+  specify "should create a temporary table" do
+    @db.create_table :test_tmp, :temp => true do
+      primary_key :id, :integer, :null => false
+      column :name, :text
+      index :name, :unique => true
+    end
+    
+    @db.sqls.should == ['CREATE TEMPORARY TABLE test_tmp (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
+      'CREATE UNIQUE INDEX test_tmp_name_index ON test_tmp (name)']
+  end
+
+  specify "should not use default schema when creating a temporary table" do
+    @db.default_schema = :foo
+    @db.create_table :test_tmp, :temp => true do
+      column :name, :text
+    end
+    @db.sqls.should == ['CREATE TEMPORARY TABLE test_tmp (name text)']
+  end
+end
+
+describe "Database#alter_table" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.alter_table :xyz do
+      add_column :aaa, :text, :null => false, :unique => true
+      drop_column :bbb
+      rename_column :ccc, :ddd
+      set_column_type :eee, :integer
+      set_column_default :hhh, 'abcd'
+      add_index :fff, :unique => true
+      drop_index :ggg
+    end
+    
+    @db.sqls.should == ['ALTER TABLE xyz ADD COLUMN aaa text NOT NULL UNIQUE',
+      'ALTER TABLE xyz DROP COLUMN bbb',
+      'ALTER TABLE xyz RENAME COLUMN ccc TO ddd',
+      'ALTER TABLE xyz ALTER COLUMN eee TYPE integer',
+      "ALTER TABLE xyz ALTER COLUMN hhh SET DEFAULT 'abcd'",
+      'CREATE UNIQUE INDEX xyz_fff_index ON xyz (fff)',
+      'DROP INDEX xyz_ggg_index']
+  end
+end
+
+describe "Database#add_column" do
+  specify "should construct proper SQL" do
+    db = Sequel.mock
+    db.add_column :test, :name, :text, :unique => true
+    db.sqls.should == ['ALTER TABLE test ADD COLUMN name text UNIQUE']
+  end
+end
+
+describe "Database#drop_column" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_column :test, :name
+    @db.sqls.should == ['ALTER TABLE test DROP COLUMN name']
+  end
+  
+  specify "should use CASCADE for :cascade=>true option" do
+    @db.drop_column :test, :name, :cascade=>true
+    @db.sqls.should == ['ALTER TABLE test DROP COLUMN name CASCADE']
+  end
+end
+
+describe "Database#rename_column" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.rename_column :test, :abc, :def
+    @db.sqls.should == ['ALTER TABLE test RENAME COLUMN abc TO def']
+  end
+end
+
+describe "Database#set_column_type" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.set_column_type :test, :name, :integer
+    @db.sqls.should == ['ALTER TABLE test ALTER COLUMN name TYPE integer']
+  end
+end
+
+describe "Database#set_column_default" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.set_column_default :test, :name, 'zyx'
+    @db.sqls.should == ["ALTER TABLE test ALTER COLUMN name SET DEFAULT 'zyx'"]
+  end
+end
+
+describe "Database#add_index" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.add_index :test, :name, :unique => true
+    @db.sqls.should == ['CREATE UNIQUE INDEX test_name_index ON test (name)']
+  end
+  
+  specify "should accept multiple columns" do
+    @db.add_index :test, [:one, :two]
+    @db.sqls.should == ['CREATE INDEX test_one_two_index ON test (one, two)']
+  end
+end
+
+describe "Database#drop_index" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_index :test, :name
+    @db.sqls.should == ['DROP INDEX test_name_index']
+  end
+  
+end
+
+describe "Database#drop_table" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_table :test
+    @db.sqls.should == ['DROP TABLE test']
+  end
+  
+  specify "should accept multiple table names" do
+    @db.drop_table :a, :bb, :ccc
+    @db.sqls.should == ['DROP TABLE a', 'DROP TABLE bb', 'DROP TABLE ccc']
+  end
+end
+
+describe "Database#rename_table" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.rename_table :abc, :xyz
+    @db.sqls.should == ['ALTER TABLE abc RENAME TO xyz']
+  end
+end
+
+describe "Database#create_view" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL with raw SQL" do
+    @db.create_view :test, "SELECT * FROM xyz"
+    @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
+    @db.create_view Sequel.identifier(:test), "SELECT * FROM xyz"
+    @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
+  end
+  
+  specify "should construct proper SQL with dataset" do
+    @db.create_view :test, @db[:items].select(:a, :b).order(:c)
+    @db.sqls.should == ['CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
+    @db.create_or_replace_view :sch__test, "SELECT * FROM xyz"
+    @db.sqls.should == ['CREATE OR REPLACE VIEW sch.test AS SELECT * FROM xyz']
+  end
+
+  specify "should construct proper SQL with dataset" do
+    @db.create_or_replace_view :test, @db[:items].select(:a, :b).order(:c)
+    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
+    @db.create_or_replace_view Sequel.identifier(:test), @db[:items].select(:a, :b).order(:c)
+    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
+  end
+end
+
+describe "Database#drop_view" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_view :test
+    @db.drop_view Sequel.identifier(:test)
+    @db.drop_view :sch__test
+    @db.drop_view Sequel.qualify(:sch, :test)
+    @db.sqls.should == ['DROP VIEW test', 'DROP VIEW test', 'DROP VIEW sch.test', 'DROP VIEW sch.test']
+  end
+
+  specify "should drop multiple views at once" do
+    @db.drop_view :cats, :dogs
+    @db.sqls.should == ['DROP VIEW cats', 'DROP VIEW dogs']
+  end
+
+  specify "should take an options hash and support the :cascade option" do
+    @db.drop_view :cats, :dogs, :cascade=>true
+    @db.sqls.should == ['DROP VIEW cats CASCADE', 'DROP VIEW dogs CASCADE']
+  end
+end
+
+describe "Database#alter_table_sql" do
+  specify "should raise error for an invalid op" do
+    proc {Sequel.mock.send(:alter_table_sql, :mau, :op => :blah)}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "Schema Parser" do
@@ -776,6 +1232,43 @@ describe "Schema Parser" do
     proc{@db.schema(:x)}.should raise_error(Sequel::Error)
   end
 
+  specify "should cache data by default" do
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      [[:a, {}]]
+    end
+    @db.schema(:x).should equal(@db.schema(:x))
+  end
+
+  specify "should not cache data if :reload=>true is given" do
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      [[:a, {}]]
+    end
+    @db.schema(:x).should_not equal(@db.schema(:x, :reload=>true))
+  end
+
+  specify "should not cache schema metadata if cache_schema is false" do
+    @db.cache_schema = false
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      [[:a, {}]]
+    end
+    @db.schema(:x).should_not equal(@db.schema(:x))
+  end
+
+  specify "should provide options if given a table name" do
+    c = nil
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      c = [t, opts]
+      [[:a, {:db_type=>t.to_s}]]
+    end
+    @db.schema(:x)
+    c.should == ["x", {}]
+    @db.schema(:s__x)
+    c.should == ["x", {:schema=>"s"}]
+    ds = @db[:s__y]
+    @db.schema(ds)
+    c.should == ["y", {:schema=>"s", :dataset=>ds}]
+  end
+
   specify "should parse the schema correctly for a single table" do
     sqls = @sqls
     proc{@db.schema(:x)}.should raise_error(Sequel::Error)
@@ -798,19 +1291,21 @@ describe "Schema Parser" do
     s1 = @db.schema(:x)
     s1.should == [['x', {:db_type=>'x', :ruby_default=>nil}]]
     @db.schema(:x).object_id.should == s1.object_id
-    @db.schema(:x.identifier).object_id.should == s1.object_id
+    @db.schema(Sequel.identifier(:x)).object_id.should == s1.object_id
     s2 = @db.schema(:x__y)
     s2.should == [['y', {:db_type=>'y', :ruby_default=>nil}]]
     @db.schema(:x__y).object_id.should == s2.object_id
-    @db.schema(:y.qualify(:x)).object_id.should == s2.object_id
+    @db.schema(Sequel.qualify(:x, :y)).object_id.should == s2.object_id
   end
 
   specify "should correctly parse all supported data types" do
-    @db.meta_def(:schema_parse_table) do |t, opts|
-      [[:x, {:type=>schema_column_type(t.to_s)}]]
+    sm = Module.new do
+      def schema_parse_table(t, opts)
+        [[:x, {:type=>schema_column_type(t.to_s)}]]
+      end
     end
+    @db.extend(sm)
     @db.schema(:tinyint).first.last[:type].should == :integer
-    @db.schema(:interval).first.last[:type].should == :interval
     @db.schema(:int).first.last[:type].should == :integer
     @db.schema(:integer).first.last[:type].should == :integer
     @db.schema(:bigint).first.last[:type].should == :integer
@@ -829,10 +1324,10 @@ describe "Schema Parser" do
     @db.schema(:"time with time zone").first.last[:type].should == :time
     @db.schema(:"time without time zone").first.last[:type].should == :time
     @db.schema(:boolean).first.last[:type].should == :boolean
-    @db.schema(:bit).first.last[:type].should == :boolean
     @db.schema(:real).first.last[:type].should == :float
     @db.schema(:float).first.last[:type].should == :float
     @db.schema(:double).first.last[:type].should == :float
+    @db.schema(:"double(1,2)").first.last[:type].should == :float
     @db.schema(:"double precision").first.last[:type].should == :float
     @db.schema(:number).first.last[:type].should == :decimal
     @db.schema(:numeric).first.last[:type].should == :decimal
@@ -852,5 +1347,13 @@ describe "Schema Parser" do
     @db.schema(:binary).first.last[:type].should == :blob
     @db.schema(:varbinary).first.last[:type].should == :blob
     @db.schema(:enum).first.last[:type].should == :enum
+
+    @db = Sequel.mock(:host=>'postgres')
+    @db.extend(sm)
+    @db.schema(:interval).first.last[:type].should == :interval
+
+    @db = Sequel.mock(:host=>'mysql')
+    @db.extend(sm)
+    @db.schema(:set).first.last[:type].should == :set
   end
 end