sequel 3.21.0 → 3.28.0

data/spec/core/expression_filters_spec.rb

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

data/spec/core/schema_spec.rb

@@ -281,6 +281,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
@@ -548,8 +555,15 @@ describe "DB#create_table!" do
     @db = SchemaDummyDatabase.new
   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
@@ -570,6 +584,12 @@ 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#drop_table" do
@@ -581,6 +601,16 @@ describe "DB#drop_table" 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#alter_table" do
@@ -709,6 +739,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 +753,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
@@ -763,6 +807,286 @@ describe "DB#alter_table" do
   end
 end
 
+describe "Database#create_table" do
+  before do
+    @db = DummyDatabase.new
+  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 = DummyDatabase.new
+  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
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @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 = DummyDatabase.new
+  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 = DummyDatabase.new
+  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 = DummyDatabase.new
+  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 = DummyDatabase.new
+  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 = DummyDatabase.new
+  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 = DummyDatabase.new
+  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 = DummyDatabase.new
+  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 = DummyDatabase.new
+  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 = DummyDatabase.new
+  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.sqls.clear
+    @db.create_view :test.identifier, "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.sqls.clear
+    @db.create_view :test.qualify(:sch), @db[:items].select(:a, :b).order(:c)
+    @db.sqls.should == ['CREATE VIEW sch.test AS SELECT a, b FROM items ORDER BY c']
+  end
+end
+
+describe "Database#create_or_replace_view" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL with raw SQL" do
+    @db.create_or_replace_view :test, "SELECT * FROM xyz"
+    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT * FROM xyz']
+    @db.sqls.clear
+    @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.sqls.clear
+    @db.create_or_replace_view :test.identifier, @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 = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_view :test
+    @db.drop_view :test.identifier
+    @db.drop_view :sch__test
+    @db.drop_view :test.qualify(:sch)
+    @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
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should raise error for an invalid op" do
+    proc {@db.send(:alter_table_sql, :mau, :op => :blah)}.should raise_error(Sequel::Error)
+  end
+end
+
 describe "Schema Parser" do
   before do
     @sqls = []
@@ -829,7 +1153,6 @@ 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