sequel 3.33.0 → 3.34.0

data/spec/core/expression_filters_spec.rb

@@ -713,4 +713,368 @@ describe Sequel::SQL::VirtualRow do
     Sequel::BasicObject.remove_methods!
     @d.l{a > adsoiwemlsdaf2}.should == '("a" > "adsoiwemlsdaf2")'
   end
+
+  it "should have operator methods defined that produce Sequel expression objects" do
+    @d.l{|o| o.&({:a=>1}, :b)}.should == '(("a" = 1) AND "b")'
+    @d.l{|o| o.|({:a=>1}, :b)}.should == '(("a" = 1) OR "b")'
+    @d.l{|o| o.+(1, :b) > 2}.should == '((1 + "b") > 2)'
+    @d.l{|o| o.-(1, :b) < 2}.should == '((1 - "b") < 2)'
+    @d.l{|o| o.*(1, :b) >= 2}.should == '((1 * "b") >= 2)'
+    @d.l{|o| o./(1, :b) <= 2}.should == '((1 / "b") <= 2)'
+    @d.l{|o| o.~(:a=>1)}.should == '("a" != 1)'
+    @d.l{|o| o.~([[:a, 1], [:b, 2]])}.should == '(("a" != 1) OR ("b" != 2))'
+    @d.l{|o| o.<(1, :b)}.should == '(1 < "b")'
+    @d.l{|o| o.>(1, :b)}.should == '(1 > "b")'
+    @d.l{|o| o.<=(1, :b)}.should == '(1 <= "b")'
+    @d.l{|o| o.>=(1, :b)}.should == '(1 >= "b")'
+  end
+
+  it "should have have ` produce literal strings" do
+    @d.l{a > `some SQL`}.should == '("a" > some SQL)'
+    @d.l{|o| o.a > o.`('some SQL')}.should == '("a" > some SQL)' #`
+  end
+end
+
+describe "Sequel core extension replacements" do
+  before do
+    @db = Sequel::Database.new
+    @o = Object.new
+    def @o.sql_literal(ds) 'foo' end
+  end
+
+  def l(arg, should)
+    @db.literal(arg).should == should
+  end
+
+  it "Sequel.expr should return an appropriate wrapped object" do
+    l(Sequel.expr(1) + 1, "(1 + 1)")
+    l(Sequel.expr('a') + 'b', "('a' || 'b')")
+    l(Sequel.expr(:b) & nil, "(b AND NULL)")
+    l(Sequel.expr(nil) & true, "(NULL AND 't')")
+    l(Sequel.expr(false) & true, "('f' AND 't')")
+    l(Sequel.expr(true) | false, "('t' OR 'f')")
+    l(Sequel.expr(@o) + 1, "(foo + 1)")
+  end
+
+  it "Sequel.expr should handle condition specifiers" do
+    l(Sequel.expr(:a=>1) & nil, "((a = 1) AND NULL)")
+    l(Sequel.expr([[:a, 1]]) & nil, "((a = 1) AND NULL)")
+    l(Sequel.expr([[:a, 1], [:b, 2]]) & nil, "((a = 1) AND (b = 2) AND NULL)")
+  end
+
+  it "Sequel.expr should treat blocks/procs as virtual rows and wrap the output" do
+    l(Sequel.expr{1} + 1, "(1 + 1)")
+    l(Sequel.expr{o__a} + 1, "(o.a + 1)")
+    l(Sequel.expr{[[:a, 1]]} & nil, "((a = 1) AND NULL)")
+    l(Sequel.expr{|v| @o} + 1, "(foo + 1)")
+
+    l(Sequel.expr(proc{1}) + 1, "(1 + 1)")
+    l(Sequel.expr(proc{o__a}) + 1, "(o.a + 1)")
+    l(Sequel.expr(proc{[[:a, 1]]}) & nil, "((a = 1) AND NULL)")
+    l(Sequel.expr(proc{|v| @o}) + 1, "(foo + 1)")
+  end
+
+  it "Sequel.expr should raise an error if given an argument and a block" do
+    proc{Sequel.expr(nil){}}.should raise_error(Sequel::Error)
+  end
+
+  it "Sequel.expr should raise an error if given neither an argument nor a block" do
+    proc{Sequel.expr}.should raise_error(Sequel::Error)
+  end
+
+  it "Sequel.expr should return existing Sequel expressions directly" do
+    o = Sequel.expr(1)
+    Sequel.expr(o).should equal(o)
+    o = Sequel.lit('1')
+    Sequel.expr(o).should equal(o)
+  end
+
+  it "Sequel.~ should invert the given object" do
+    l(Sequel.~(nil), 'NOT NULL')
+    l(Sequel.~(:a=>1), "(a != 1)")
+    l(Sequel.~([[:a, 1]]), "(a != 1)")
+    l(Sequel.~([[:a, 1], [:b, 2]]), "((a != 1) OR (b != 2))")
+    l(Sequel.~(Sequel.expr([[:a, 1], [:b, 2]]) & nil), "((a != 1) OR (b != 2) OR NOT NULL)")
+  end
+
+  it "Sequel.case should use a CASE expression" do
+    l(Sequel.case({:a=>1}, 2), "(CASE WHEN a THEN 1 ELSE 2 END)")
+    l(Sequel.case({:a=>1}, 2, :b), "(CASE b WHEN a THEN 1 ELSE 2 END)")
+    l(Sequel.case([[:a, 1]], 2), "(CASE WHEN a THEN 1 ELSE 2 END)")
+    l(Sequel.case([[:a, 1]], 2, :b), "(CASE b WHEN a THEN 1 ELSE 2 END)")
+    l(Sequel.case([[:a, 1], [:c, 3]], 2), "(CASE WHEN a THEN 1 WHEN c THEN 3 ELSE 2 END)")
+    l(Sequel.case([[:a, 1], [:c, 3]], 2, :b), "(CASE b WHEN a THEN 1 WHEN c THEN 3 ELSE 2 END)")
+  end
+
+  it "Sequel.case should raise an error if not given a condition specifier" do
+    proc{Sequel.case(1, 2)}.should raise_error(Sequel::Error)
+  end
+
+  it "Sequel.value_list should use an SQL value list" do
+    l(Sequel.value_list([[1, 2]]), "((1, 2))")
+  end
+
+  it "Sequel.value_list raise an error if not given an array" do
+    proc{Sequel.value_list(1)}.should raise_error(Sequel::Error)
+  end
+
+  it "Sequel.negate should negate all entries in conditions specifier and join with AND" do
+    l(Sequel.negate(:a=>1), "(a != 1)")
+    l(Sequel.negate([[:a, 1]]), "(a != 1)")
+    l(Sequel.negate([[:a, 1], [:b, 2]]), "((a != 1) AND (b != 2))")
+  end
+
+  it "Sequel.negate should raise an error if not given a conditions specifier" do
+    proc{Sequel.negate(1)}.should raise_error(Sequel::Error)
+  end
+
+  it "Sequel.or should join all entries in conditions specifier with OR" do
+    l(Sequel.or(:a=>1), "(a = 1)")
+    l(Sequel.or([[:a, 1]]), "(a = 1)")
+    l(Sequel.or([[:a, 1], [:b, 2]]), "((a = 1) OR (b = 2))")
+  end
+
+  it "Sequel.or should raise an error if not given a conditions specifier" do
+    proc{Sequel.or(1)}.should raise_error(Sequel::Error)
+  end
+
+  it "Sequel.join should should use SQL string concatenation to join array" do
+    l(Sequel.join([]), "''")
+    l(Sequel.join(['a']), "('a')")
+    l(Sequel.join(['a', 'b']), "('a' || 'b')")
+    l(Sequel.join(['a', 'b'], 'c'), "('a' || 'c' || 'b')")
+    l(Sequel.join([true, :b], :c), "('t' || c || b)")
+    l(Sequel.join([false, nil], Sequel.lit('c')), "('f' || c || NULL)")
+    l(Sequel.join([Sequel.expr('a'), Sequel.lit('d')], 'c'), "('a' || 'c' || d)")
+  end
+
+  it "Sequel.join should raise an error if not given an array" do
+    proc{Sequel.join(1)}.should raise_error(Sequel::Error)
+  end
+
+  it "Sequel.& should join all arguments given with AND" do
+    l(Sequel.&(:a), "(a)")
+    l(Sequel.&(:a, :b=>:c), "(a AND (b = c))")
+    l(Sequel.&(:a, {:b=>:c}, Sequel.lit('d')), "(a AND (b = c) AND d)")
+  end
+
+  it "Sequel.& should raise an error if given no arguments" do
+    proc{Sequel.&}.should raise_error(Sequel::Error)
+  end
+
+  it "Sequel.| should join all arguments given with OR" do
+    l(Sequel.|(:a), "(a)")
+    l(Sequel.|(:a, :b=>:c), "(a OR (b = c))")
+    l(Sequel.|(:a, {:b=>:c}, Sequel.lit('d')), "(a OR (b = c) OR d)")
+  end
+
+  it "Sequel.| should raise an error if given no arguments" do
+    proc{Sequel.|}.should raise_error(Sequel::Error)
+  end
+
+  it "Sequel.as should return an aliased expression" do
+    l(Sequel.as(:a, :b), "a AS b")
+  end
+
+  it "Sequel.cast should return a CAST expression" do
+    l(Sequel.cast(:a, :int), "CAST(a AS int)")
+    l(Sequel.cast(:a, Integer), "CAST(a AS integer)")
+  end
+
+  it "Sequel.cast_numeric should return a CAST expression treated as a number" do
+    l(Sequel.cast_numeric(:a), "CAST(a AS integer)")
+    l(Sequel.cast_numeric(:a, :int), "CAST(a AS int)")
+    l(Sequel.cast_numeric(:a) << 2, "(CAST(a AS integer) << 2)")
+  end
+
+  it "Sequel.cast_string should return a CAST expression treated as a string" do
+    l(Sequel.cast_string(:a), "CAST(a AS varchar(255))")
+    l(Sequel.cast_string(:a, :text), "CAST(a AS text)")
+    l(Sequel.cast_string(:a) + 'a', "(CAST(a AS varchar(255)) || 'a')")
+  end
+
+  it "Sequel.lit should return a literal string" do
+    l(Sequel.lit('a'), "a")
+  end
+
+  it "Sequel.lit should return the argument if given a single literal string" do
+    o = Sequel.lit('a')
+    Sequel.lit(o).should equal(o)
+  end
+
+  it "Sequel.lit should accept multiple arguments for a placeholder literal string" do
+    l(Sequel.lit('a = ?', 1), "a = 1")
+    l(Sequel.lit('? = ?', :a, 1), "a = 1")
+    l(Sequel.lit('a = :a', :a=>1), "a = 1")
+  end
+
+  it "Sequel.lit should work with an array for the placeholder string" do
+    l(Sequel.lit(['a = '], 1), "a = 1")
+    l(Sequel.lit(['', ' = '], :a, 1), "a = 1")
+  end
+
+  it "Sequel.blob should return an SQL::Blob" do
+    l(Sequel.blob('a'), "'a'")
+    Sequel.blob('a').should be_a_kind_of(Sequel::SQL::Blob)
+  end
+
+  it "Sequel.blob should return the given argument if given a blob" do
+    o = Sequel.blob('a')
+    Sequel.blob(o).should equal(o)
+  end
+
+  it "Sequel.qualify should return a qualified identifier" do
+    l(Sequel.qualify(:t, :c), "t.c")
+  end
+
+  it "Sequel.identifier should return an identifier" do
+    l(Sequel.identifier(:t__c), "t__c")
+  end
+
+  it "Sequel.asc should return an ASC ordered expression" do
+    l(Sequel.asc(:a), "a ASC")
+    l(Sequel.asc(:a, :nulls=>:first), "a ASC NULLS FIRST")
+  end
+
+  it "Sequel.desc should return a DESC ordered expression " do
+    l(Sequel.desc(:a), "a DESC")
+    l(Sequel.desc(:a, :nulls=>:last), "a DESC NULLS LAST")
+  end
+
+  it "Sequel.{+,-,*,/} should accept arguments and use the appropriate operator" do
+    %w'+ - * /'.each do |op|
+      l(Sequel.send(op, 1), '(1)')
+      l(Sequel.send(op, 1, 2), "(1 #{op} 2)")
+      l(Sequel.send(op, 1, 2, 3), "(1 #{op} 2 #{op} 3)")
+    end
+  end
+
+  it "Sequel.{+,-,*,/} should raise if given no arguments" do
+    %w'+ - * /'.each do |op|
+      proc{Sequel.send(op)}.should raise_error(Sequel::Error)
+    end
+  end
+
+  it "Sequel.like should use a LIKE expression" do
+    l(Sequel.like('a', 'b'), "('a' LIKE 'b')")
+    l(Sequel.like(:a, :b), "(a LIKE b)")
+    l(Sequel.like(:a, /b/), "(a ~ 'b')")
+    l(Sequel.like(:a, 'c', /b/), "((a LIKE 'c') OR (a ~ 'b'))")
+  end
+
+  it "Sequel.ilike should use an ILIKE expression" do
+    l(Sequel.ilike('a', 'b'), "('a' ILIKE 'b')")
+    l(Sequel.ilike(:a, :b), "(a ILIKE b)")
+    l(Sequel.ilike(:a, /b/), "(a ~* 'b')")
+    l(Sequel.ilike(:a, 'c', /b/), "((a ILIKE 'c') OR (a ~* 'b'))")
+  end
+
+  it "Sequel.subscript should use an SQL subscript" do
+    l(Sequel.subscript(:a, 1), 'a[1]')
+    l(Sequel.subscript(:a, 1, 2), 'a[1, 2]')
+    l(Sequel.subscript(:a, [1, 2]), 'a[1, 2]')
+  end
+
+  it "Sequel.function should return an SQL function" do
+    l(Sequel.function(:a), 'a()')
+    l(Sequel.function(:a, 1), 'a(1)')
+    l(Sequel.function(:a, :b, 2), 'a(b, 2)')
+  end
+
+  it "Sequel.extract should use a date/time extraction" do
+    l(Sequel.extract(:year, :a), 'extract(year FROM a)')
+  end
+end
+
+describe "Sequel::SQL::Function#==" do
+  specify "should be true for functions with the same name and arguments, false otherwise" do
+    a = :date.sql_function(:t)
+    b = :date.sql_function(:t)
+    a.should == b
+    (a == b).should == true
+    c = :date.sql_function(:c)
+    a.should_not == c
+    (a == c).should == false
+    d = :time.sql_function(:c)
+    a.should_not == d
+    c.should_not == d
+    (a == d).should == false
+    (c == d).should == false
+  end
+end
+
+describe "Sequel::SQL::OrderedExpression" do
+  specify "should #desc" do
+    @oe = Sequel.asc(:column)
+    @oe.descending.should == false
+    @oe.desc.descending.should == true
+  end
+
+  specify "should #asc" do
+    @oe = Sequel.desc(:column)
+    @oe.descending.should == true
+    @oe.asc.descending.should == false
+  end
+
+  specify "should #invert" do
+    @oe = Sequel.desc(:column)
+    @oe.invert.descending.should == false
+    @oe.invert.invert.descending.should == true
+  end
+end
+
+describe "Expression" do
+  specify "should consider objects == only if they have the same attributes" do
+    :column.qualify(:table).cast(:type).*(:numeric_column).asc.should == :column.qualify(:table).cast(:type).*(:numeric_column).asc
+    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.should_not == :column.qualify(:table).cast(:type).*(:numeric_column).asc
+
+    :column.qualify(:table).cast(:type).*(:numeric_column).asc.should eql(:column.qualify(:table).cast(:type).*(:numeric_column).asc)
+    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.should_not eql(:column.qualify(:table).cast(:type).*(:numeric_column).asc)
+  end
+
+  specify "should use the same hash value for objects that have the same attributes" do
+    :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash.should == :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash
+    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.hash.should_not == :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash
+
+    h = {}
+    a = :column.qualify(:table).cast(:type).*(:numeric_column).asc
+    b = :column.qualify(:table).cast(:type).*(:numeric_column).asc
+    h[a] = 1
+    h[b] = 2
+    h[a].should == 2
+    h[b].should == 2
+  end
+end
+
+describe "Sequel::SQLTime" do
+  before do
+    @db = Sequel.mock
+  end
+
+  specify ".create should create from hour, minutes, seconds and optional microseconds" do
+    @db.literal(Sequel::SQLTime.create(1, 2, 3)).should == "'01:02:03.000000'"
+    @db.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).should == "'01:02:03.500000'"
+  end
+end
+
+describe "Sequel::SQL::Wrapper" do
+  before do
+    @ds = Sequel.mock.dataset
+  end
+
+  specify "should wrap objects so they can be used by the Sequel DSL" do
+    o = Object.new
+    def o.sql_literal(ds) 'foo' end
+    s = Sequel::SQL::Wrapper.new(o)
+    @ds.literal(s).should == "foo"
+    @ds.literal(s+1).should == "(foo + 1)"
+    @ds.literal(s & true).should == "(foo AND 't')"
+    @ds.literal(s < 1).should == "(foo < 1)"
+    @ds.literal(s.sql_subscript(1)).should == "foo[1]"
+    @ds.literal(s.like('a')).should == "(foo LIKE 'a')"
+    @ds.literal(s.as(:a)).should == "foo AS a"
+    @ds.literal(s.cast(Integer)).should == "CAST(foo AS integer)"
+    @ds.literal(s.desc).should == "foo DESC"
+    @ds.literal(s.sql_string + '1').should == "(foo || '1')"
+  end
 end

data/spec/core/mock_adapter_spec.rb

@@ -17,13 +17,16 @@ describe "Sequel Mock Adapter" do
     called.should be_false
   end
 
-  specify "should return 0 for update and delete by default" do
+  specify "should return 0 for update/delete/with_sql_delete/execute_dui by default" do
     Sequel.mock[:t].update(:a=>1).should == 0
     Sequel.mock[:t].delete.should == 0
+    Sequel.mock[:t].with_sql_delete('DELETE FROM t').should == 0
+    Sequel.mock.execute_dui('DELETE FROM t').should == 0
   end
 
-  specify "should return nil for insert by default" do
+  specify "should return nil for insert/execute_insert by default" do
     Sequel.mock[:t].insert(:a=>1).should be_nil
+    Sequel.mock.execute_insert('INSERT INTO a () DEFAULT VALUES').should be_nil
   end
 
   specify "should be able to set the rows returned by each using :fetch option with a single hash" do
@@ -299,6 +302,13 @@ describe "Sequel Mock Adapter" do
     Sequel.mock.send(:quote_identifiers_default).should be_false
   end
 
+  specify "should allow overriding of server_version" do
+    db = Sequel.mock
+    db.server_version.should == nil
+    db.server_version = 80102
+    db.server_version.should == 80102
+  end
+
   specify "should not have identifier input/output methods by default" do
     Sequel.mock.send(:identifier_input_method_default).should be_nil
     Sequel.mock.send(:identifier_output_method_default).should be_nil
@@ -420,7 +430,7 @@ describe "Sequel Mock Adapter" do
       Sequel.mock(:host=>'mssql')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
       Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
       Sequel.mock(:host=>'oracle')[:a].limit(1).sql.should == 'SELECT * FROM (SELECT * FROM "A") "T1" WHERE (ROWNUM <= 1)'
-      Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM \"a\" WHERE (to_tsvector('simple', (COALESCE(\"b\", ''))) @@ to_tsquery('simple', 'c'))"
+      Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM \"a\" WHERE (to_tsvector('simple'::regconfig, (COALESCE(\"b\", ''))) @@ to_tsquery('simple'::regconfig, 'c'))"
       Sequel.mock(:host=>'sqlite')[:a___b].sql.should == "SELECT * FROM `a` AS 'b'"
     ensure
       Sequel.quote_identifiers = qi
@@ -428,4 +438,8 @@ describe "Sequel Mock Adapter" do
       Sequel::Database.send(:class_variable_set, :@@identifier_output_method, io)
     end
   end
+
+  specify "should automatically set version for postgres" do
+    Sequel.mock(:host=>'postgres').server_version.should == 90103
+  end
 end

data/spec/core/schema_spec.rb

@@ -227,6 +227,11 @@ describe "DB#create_table" 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.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
@@ -254,6 +259,11 @@ describe "DB#create_table" 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.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
@@ -569,6 +579,87 @@ describe "DB#create_table?" do
   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 = Sequel.mock
@@ -590,6 +681,48 @@ describe "DB#drop_table" do
   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 = Sequel.mock