sequel 4.49.0 → 5.3.0

data/spec/core/deprecated_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+require_relative "spec_helper"
 
 describe "Sequel::Deprecated" do
   before do
@@ -27,7 +27,7 @@ describe "Sequel::Deprecated" do
 
   it "should consider two arguments to be a method name and additional text" do
     @d.deprecate("foo", "Use bar instead")
-    @output.must_equal ['foo is deprecated and will be removed in Sequel 5.  Use bar instead.']
+    @output.must_equal ['foo is deprecated and will be removed in Sequel 5.1.  Use bar instead.']
   end
 
   it "should include a prefix if set" do
@@ -67,4 +67,4 @@ describe "Sequel::Deprecated" do
     @output.first.must_equal 'foo'
     @output.count.must_equal 4
   end
-end if RUBY_VERSION >= '1.9'
+end

data/spec/core/expression_filters_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+require_relative "spec_helper"
 
 describe "Blockless Ruby Filters" do
   before do
@@ -13,6 +13,12 @@ describe "Blockless Ruby Filters" do
     end
   end
   
+  it "should support boolean columns directly" do
+    x = Sequel[:x]
+    x.dup.must_be_same_as x
+    x.clone.must_be_same_as x
+  end
+  
   it "should support boolean columns directly" do
     @d.l(:x).must_equal 'x'
   end
@@ -23,30 +29,15 @@ describe "Blockless Ruby Filters" do
     @d.l(:x__y___z).must_equal 'x.y AS z'
   end
 
-  deprecated "should support qualified columns and aliased columns using symbols 2" do
-    @d.l(:x__y).must_equal 'x.y'
-    @d.l(:x___y).must_equal 'x AS y'
-    @d.l(:x__y___z).must_equal 'x.y AS z'
-  end
-
   with_symbol_splitting "should support qualified columns using virtual rows" do
     @d.l(Sequel.expr{x__y}).must_equal 'x.y'
   end
 
-  deprecated "should support qualified columns using virtual rows" do
-    @d.l(Sequel.expr{x__y}).must_equal 'x.y'
-  end
-
   it "should not split symbols or virtual row methods if symbol splitting is disabled" do
-    begin
-      Sequel.split_symbols = false
-      @d.l(:x__y).must_equal 'x__y'
-      @d.l(:x___y).must_equal 'x___y'
-      @d.l(:x__y___z).must_equal 'x__y___z'
-      @d.l(Sequel.expr{x__y}).must_equal 'x__y'
-    ensure
-      Sequel.split_symbols = :deprecated
-    end
+    @d.l(:x__y).must_equal 'x__y'
+    @d.l(:x___y).must_equal 'x___y'
+    @d.l(:x__y___z).must_equal 'x__y___z'
+    @d.l(Sequel.expr{x__y}).must_equal 'x__y'
   end
 
   it "should support NOT with SQL functions" do
@@ -110,28 +101,26 @@ describe "Blockless Ruby Filters" do
     @d.l{(x + y) =~ /blah/}.must_equal '((x + y) ~ \'blah\')'
   end
 
-  if RUBY_VERSION >= '1.9'
-    it "should support != and similar inversions via !~ method" do
-      @d.l{x !~ 100}.must_equal '(x != 100)'
-      @d.l{x !~ 'a'}.must_equal '(x != \'a\')'
-      @d.l{x !~ true}.must_equal '(x IS NOT TRUE)'
-      @d.l{x !~ false}.must_equal '(x IS NOT FALSE)'
-      @d.l{x !~ nil}.must_equal '(x IS NOT NULL)'
-      @d.l{x !~ (1...5)}.must_equal '((x < 1) OR (x >= 5))'
-      @d.l{x !~ [1,2,3]}.must_equal '(x NOT IN (1, 2, 3))'
-
-      @d.l{(x + y) !~ 100}.must_equal '((x + y) != 100)'
-      @d.l{(x + y) !~ 'a'}.must_equal '((x + y) != \'a\')'
-      @d.l{(x + y) !~ true}.must_equal '((x + y) IS NOT TRUE)'
-      @d.l{(x + y) !~ false}.must_equal '((x + y) IS NOT FALSE)'
-      @d.l{(x + y) !~ nil}.must_equal '((x + y) IS NOT NULL)'
-      @d.l{(x + y) !~ (1...5)}.must_equal '(((x + y) < 1) OR ((x + y) >= 5))'
-      @d.l{(x + y) !~ [1,2,3]}.must_equal '((x + y) NOT IN (1, 2, 3))'
-
-      @d = @d.with_extend{def supports_regexp?; true end}
-      @d.l{x !~ /blah/}.must_equal '(x !~ \'blah\')'
-      @d.l{(x + y) !~ /blah/}.must_equal '((x + y) !~ \'blah\')'
-    end
+  it "should support != and similar inversions via !~ method" do
+    @d.l{x !~ 100}.must_equal '(x != 100)'
+    @d.l{x !~ 'a'}.must_equal '(x != \'a\')'
+    @d.l{x !~ true}.must_equal '(x IS NOT TRUE)'
+    @d.l{x !~ false}.must_equal '(x IS NOT FALSE)'
+    @d.l{x !~ nil}.must_equal '(x IS NOT NULL)'
+    @d.l{x !~ (1...5)}.must_equal '((x < 1) OR (x >= 5))'
+    @d.l{x !~ [1,2,3]}.must_equal '(x NOT IN (1, 2, 3))'
+
+    @d.l{(x + y) !~ 100}.must_equal '((x + y) != 100)'
+    @d.l{(x + y) !~ 'a'}.must_equal '((x + y) != \'a\')'
+    @d.l{(x + y) !~ true}.must_equal '((x + y) IS NOT TRUE)'
+    @d.l{(x + y) !~ false}.must_equal '((x + y) IS NOT FALSE)'
+    @d.l{(x + y) !~ nil}.must_equal '((x + y) IS NOT NULL)'
+    @d.l{(x + y) !~ (1...5)}.must_equal '(((x + y) < 1) OR ((x + y) >= 5))'
+    @d.l{(x + y) !~ [1,2,3]}.must_equal '((x + y) NOT IN (1, 2, 3))'
+
+    @d = @d.with_extend{def supports_regexp?; true end}
+    @d.l{x !~ /blah/}.must_equal '(x !~ \'blah\')'
+    @d.l{(x + y) !~ /blah/}.must_equal '((x + y) !~ \'blah\')'
   end
   
   it "should support ~ via Hash and Regexp (if supported by database)" do
@@ -330,17 +319,6 @@ describe "Blockless Ruby Filters" do
     proc{Sequel::SQL::BooleanExpression.invert(Sequel.expr(:x) + 2)}.must_raise(Sequel::Error)
   end
 
-  deprecated "should return self on .lit" do
-    y = Sequel.expr(:x) + 1
-    y.lit.must_equal y
-  end
-
-  deprecated "should return have .sql_literal return the literal SQL for the expression" do
-    y = Sequel.expr(:x) + 1
-    y.sql_literal(@d).must_equal '(x + 1)'
-    y.sql_literal(@d).must_equal @d.literal(y)
-  end
-
   it "should support SQL::Constants" do
     @d.l({:x => Sequel::NULL}).must_equal '(x IS NULL)'
     @d.l({:x => Sequel::NOTNULL}).must_equal '(x IS NOT NULL)'
@@ -549,18 +527,11 @@ describe Sequel::SQL::VirtualRow do
     @d.l{function(arg1, 10, 'arg3')}.must_equal 'function("arg1", 10, \'arg3\')'
   end
 
-  deprecated "should treat methods with a block and no arguments as a function call with no arguments" do
-    @d.l{version{}}.must_equal 'version()'
-  end
 
   it "should treat methods followed by function as a function call with no arguments" do
     @d.l{version.function}.must_equal 'version()'
   end
 
-  deprecated "should treat methods with a block and a leading argument :* as a function call with the SQL wildcard" do
-    @d.l{count(:*){}}.must_equal 'count(*)'
-  end
-
   it "should treat methods followed by function.* as a function call with * argument" do
     @d.l{count.function.*}.must_equal 'count(*)'
   end
@@ -574,67 +545,11 @@ describe Sequel::SQL::VirtualRow do
     @d.literal(Sequel.expr{sum(1) * 2}).must_equal '(sum(1) * 2)'
   end
 
-  deprecated "should treat methods with a block and a leading argument :distinct as a function call with DISTINCT and the additional method arguments" do
-    @d.l{count(:distinct, column1){}}.must_equal 'count(DISTINCT "column1")'
-    @d.l{count(:distinct, column1, column2){}}.must_equal 'count(DISTINCT "column1", "column2")'
-  end
-
   it "should support distinct methods on functions to use DISTINCT before the arguments" do
     @d.l{count(column1).distinct}.must_equal 'count(DISTINCT "column1")'
     @d.l{count(column1, column2).distinct}.must_equal 'count(DISTINCT "column1", "column2")'
   end
 
-  deprecated "should raise an error if an unsupported argument is used with a block" do
-    proc{@d.where{count(:blah){}}}.must_raise(Sequel::Error)
-  end
-
-  deprecated "should treat methods with a block and a leading argument :over as a window function call" do
-    @d.l{rank(:over){}}.must_equal 'rank() OVER ()'
-  end
-
-  deprecated "should support :partition options for window function calls" do
-    @d.l{rank(:over, :partition=>column1){}}.must_equal 'rank() OVER (PARTITION BY "column1")'
-    @d.l{rank(:over, :partition=>[column1, column2]){}}.must_equal 'rank() OVER (PARTITION BY "column1", "column2")'
-  end
-
-  deprecated "should support :args options for window function calls" do
-    @d.l{avg(:over, :args=>column1){}}.must_equal 'avg("column1") OVER ()'
-    @d.l{avg(:over, :args=>[column1, column2]){}}.must_equal 'avg("column1", "column2") OVER ()'
-  end
-
-  deprecated "should support :order option for window function calls" do
-    @d.l{rank(:over, :order=>column1){}}.must_equal 'rank() OVER (ORDER BY "column1")'
-    @d.l{rank(:over, :order=>[column1, column2]){}}.must_equal 'rank() OVER (ORDER BY "column1", "column2")'
-  end
-
-  deprecated "should support :window option for window function calls" do
-    @d.l{rank(:over, :window=>:win){}}.must_equal 'rank() OVER ("win")'
-  end
-
-  deprecated "should support :*=>true option for window function calls" do
-    @d.l{count(:over, :* =>true){}}.must_equal 'count(*) OVER ()'
-  end
-
-  deprecated "should support :frame=>:all option for window function calls" do
-    @d.l{rank(:over, :frame=>:all){}}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)'
-  end
-
-  deprecated "should support :frame=>:rows option for window function calls" do
-    @d.l{rank(:over, :frame=>:rows){}}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
-  end
-
-  deprecated "should support :frame=>'some string' option for window function calls" do
-    @d.l{rank(:over, :frame=>'RANGE BETWEEN 3 PRECEDING AND CURRENT ROW'){}}.must_equal 'rank() OVER (RANGE BETWEEN 3 PRECEDING AND CURRENT ROW)'
-  end
-
-  deprecated "should raise an error if an invalid :frame option is used" do
-    proc{@d.l{rank(:over, :frame=>:blah){}}}.must_raise(Sequel::Error)
-  end
-
-  deprecated "should support all these options together" do
-    @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.must_equal 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
-  end
-
   it "should handle method.function.over as a window function call" do
     @d.l{rank.function.over}.must_equal 'rank() OVER ()'
   end
@@ -779,23 +694,6 @@ describe Sequel::SQL::VirtualRow do
     @d.l{num < Math::PI.to_i}.must_equal "(\"num\" < 3)"
   end
   
-  deprecated "should deal with methods added to Object after requiring Sequel" do
-    class Object
-      def adsoiwemlsdaf; 42; end
-    end
-    Sequel::BasicObject.remove_methods!
-    @d.l{a > adsoiwemlsdaf}.must_equal '("a" > "adsoiwemlsdaf")'
-  end
-  
-  deprecated "should deal with private methods added to Kernel after requiring Sequel" do
-    module Kernel
-      private
-      def adsoiwemlsdaf2; 42; end
-    end
-    Sequel::BasicObject.remove_methods!
-    @d.l{a > adsoiwemlsdaf2}.must_equal '("a" > "adsoiwemlsdaf2")'
-  end
-
   it "should have operator methods defined that produce Sequel expression objects" do
     @d.l{|o| o.&({:a=>1}, :b)}.must_equal '(("a" = 1) AND "b")'
     @d.l{|o| o.|({:a=>1}, :b)}.must_equal '(("a" = 1) OR "b")'
@@ -811,11 +709,6 @@ describe Sequel::SQL::VirtualRow do
     @d.l{|o| o.<=(1, :b)}.must_equal '(1 <= "b")'
     @d.l{|o| o.>=(1, :b)}.must_equal '(1 >= "b")'
   end
-
-  deprecated "should have have ` produce literal strings" do
-    @d.l{a > `some SQL`}.must_equal '("a" > some SQL)'
-    @d.l{|o| o.a > o.`('some SQL')}.must_equal '("a" > some SQL)' #`
-  end
 end
 
 describe "Sequel core extension replacements" do
@@ -1044,13 +937,9 @@ describe "Sequel core extension replacements" do
     o = Sequel.blob(('a'..'z').to_a.join)
     o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=26 start=\"abcdefghij\" end=\"qrstuvwxyz\">"
     o = Sequel.blob(255.chr)
-    o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=1 content=\"#{RUBY_VERSION >= '1.9' ? "\\xFF" : "\\377"}\">"
+    o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=1 content=\"\\xFF\">"
     o = Sequel.blob((230..255).map(&:chr).join)
-    if RUBY_VERSION >= '1.9'
-      o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=26 start=\"\\xE6\\xE7\\xE8\\xE9\\xEA\\xEB\\xEC\\xED\\xEE\\xEF\" end=\"\\xF6\\xF7\\xF8\\xF9\\xFA\\xFB\\xFC\\xFD\\xFE\\xFF\">"
-    else
-      o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=26 start=\"\\346\\347\\350\\351\\352\\353\\354\\355\\356\\357\" end=\"\\366\\367\\370\\371\\372\\373\\374\\375\\376\\377\">"
-    end
+    o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=26 start=\"\\xE6\\xE7\\xE8\\xE9\\xEA\\xEB\\xEC\\xED\\xEE\\xEF\" end=\"\\xF6\\xF7\\xF8\\xF9\\xFA\\xFB\\xFC\\xFD\\xFE\\xFF\">"
   end
 
   it "Sequel.deep_qualify should do a deep qualification into nested structors" do
@@ -1129,6 +1018,10 @@ describe "Sequel core extension replacements" do
     l(Sequel.subscript(:a, 1...3), 'a[1:2]')
   end
 
+  it "Sequel.subscript.f should be subscript expression for backwards compatibility" do
+    Sequel.subscript(:a, 1).f.must_equal :a
+  end
+
   it "Sequel.function should return an SQL function" do
     l(Sequel.function(:a), 'a()')
     l(Sequel.function(:a, 1), 'a(1)')

data/spec/core/mock_adapter_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe "Sequel Mock Adapter" do
   it "should have an adapter method" do
@@ -310,7 +310,7 @@ describe "Sequel Mock Adapter" do
   it "should be able to set the columns to set in the dataset as an array of arrays of symbols" do
     db = Sequel.mock(:columns=>[[:a, :b], [:c, :d]])
     db[:t].columns.must_equal [:a, :b]
-    db[:t].columns.must_equal [:c, :d]
+    db[:x].columns.must_equal [:c, :d]
   end
 
   it "should be able to set the columns to set in the dataset as a proc" do
@@ -323,7 +323,7 @@ describe "Sequel Mock Adapter" do
     db = Sequel.mock
     db.columns = [[:a, :b], [:c, :d]]
     db[:t].columns.must_equal [:a, :b]
-    db[:t].columns.must_equal [:c, :d]
+    db[:x].columns.must_equal [:c, :d]
   end
 
   it "should raise Error if given an invalid columns" do
@@ -451,7 +451,7 @@ describe "Sequel Mock Adapter" do
   it "should be able to load dialects based on the database name" do
     Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.must_equal 'SELECT #2011-12-13#'
     Sequel.mock(:host=>'db2').select(1).sql.must_equal 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
-    Sequel.mock(:host=>'mssql', :identifier_mangling=>false)[:A].full_text_search(:B, 'C').with_quote_identifiers(false).sql.must_equal "SELECT * FROM A WHERE (CONTAINS (B, 'C'))"
+    Sequel.mock(:host=>'mssql')[:A].full_text_search(:B, 'C').with_quote_identifiers(false).sql.must_equal "SELECT * FROM A WHERE (CONTAINS (B, 'C'))"
     Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').with_quote_identifiers(false).sql.must_equal "SELECT * FROM a WHERE (MATCH (b) AGAINST ('c'))"
     Sequel.mock(:host=>'oracle')[:a].limit(1).with_quote_identifiers(false).sql.upcase.must_equal 'SELECT * FROM (SELECT * FROM A) T1 WHERE (ROWNUM <= 1)'
     Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').with_quote_identifiers(false).sql.must_equal "SELECT * FROM a WHERE (to_tsvector(CAST('simple' AS regconfig), (COALESCE(b, ''))) @@ to_tsquery(CAST('simple' AS regconfig), 'c'))"
@@ -483,3 +483,240 @@ describe "Sequel Mock Adapter" do
     Sequel.mock(:host=>'oracle').create_table(:a){String :b}
   end
 end
+
+describe "PostgreSQL support" do
+  before do
+    @db = Sequel.mock(:host=>'postgres')
+  end
+
+  it "should create an unlogged table" do
+    @db.create_table(:unlogged_dolls, :unlogged => true){text :name}
+    @db.sqls.must_equal ['CREATE UNLOGGED TABLE "unlogged_dolls" ("name" text)']
+  end
+
+  it "should support spatial indexes" do
+    @db.alter_table(:posts){add_spatial_index [:geom]}
+    @db.sqls.must_equal ['CREATE INDEX "posts_geom_index" ON "posts" USING gist ("geom")']
+  end
+
+  it "should support indexes with index type" do
+    @db.alter_table(:posts){add_index :p, :type => 'gist'}
+    @db.sqls.must_equal ['CREATE INDEX "posts_p_index" ON "posts" USING gist ("p")']
+  end
+
+  it "should have #transaction support various types of synchronous options" do
+    @db.transaction(:synchronous=>:on){}
+    @db.transaction(:synchronous=>true){}
+    @db.transaction(:synchronous=>:off){}
+    @db.transaction(:synchronous=>false){}
+    @db.sqls.grep(/synchronous/).must_equal ["SET LOCAL synchronous_commit = on", "SET LOCAL synchronous_commit = on", "SET LOCAL synchronous_commit = off", "SET LOCAL synchronous_commit = off"]
+
+    @db.transaction(:synchronous=>nil){}
+    @db.sqls.must_equal ['BEGIN', 'COMMIT']
+
+    if @db.server_version >= 90100
+      @db.transaction(:synchronous=>:local){}
+      @db.sqls.grep(/synchronous/).must_equal ["SET LOCAL synchronous_commit = local"]
+
+      if @db.server_version >= 90200
+        @db.transaction(:synchronous=>:remote_write){}
+        @db.sqls.grep(/synchronous/).must_equal ["SET LOCAL synchronous_commit = remote_write"]
+      end
+    end
+  end
+
+  it "should have #transaction support read only transactions" do
+    @db.transaction(:read_only=>true){}
+    @db.transaction(:read_only=>false){}
+    @db.transaction(:isolation=>:serializable, :read_only=>true){}
+    @db.transaction(:isolation=>:serializable, :read_only=>false){}
+    @db.sqls.grep(/READ/).must_equal ["SET TRANSACTION READ ONLY", "SET TRANSACTION READ WRITE", "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY", "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE"]
+  end
+
+  it "should have #transaction support deferrable transactions" do
+    @db.transaction(:deferrable=>true){}
+    @db.transaction(:deferrable=>false){}
+    @db.transaction(:deferrable=>true, :read_only=>true){}
+    @db.transaction(:deferrable=>false, :read_only=>false){}
+    @db.transaction(:isolation=>:serializable, :deferrable=>true, :read_only=>true){}
+    @db.transaction(:isolation=>:serializable, :deferrable=>false, :read_only=>false){}
+    @db.sqls.grep(/DEF/).must_equal ["SET TRANSACTION DEFERRABLE", "SET TRANSACTION NOT DEFERRABLE", "SET TRANSACTION READ ONLY DEFERRABLE", "SET TRANSACTION READ WRITE NOT DEFERRABLE",  "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY DEFERRABLE", "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE NOT DEFERRABLE"]
+  end
+
+  it "should support creating indexes concurrently" do
+    @db.add_index :test, [:name, :value], :concurrently=>true
+    @db.sqls.must_equal ['CREATE INDEX CONCURRENTLY "test_name_value_index" ON "test" ("name", "value")']
+  end
+
+  it "should support dropping indexes concurrently" do
+    @db.drop_index :test, [:name, :value], :concurrently=>true, :name=>'tnv2'
+    @db.sqls.must_equal ['DROP INDEX CONCURRENTLY "tnv2"']
+  end
+
+  it "should use INSERT RETURNING for inserts" do
+    @db[:test5].insert(:value=>10)
+    @db.sqls.must_equal ['INSERT INTO "test5" ("value") VALUES (10) RETURNING "id"']
+  end
+
+  it "should support opclass specification" do
+    @db.alter_table(:posts){add_index(:user_id, :opclass => :int4_ops, :type => :btree)}
+    @db.sqls.must_equal ['CREATE INDEX "posts_user_id_index" ON "posts" USING btree ("user_id" int4_ops)']
+  end
+
+  it 'should quote NaN' do
+    nan = 0.0/0.0
+    @db[:test5].insert_sql(:value => nan).must_equal %q{INSERT INTO "test5" ("value") VALUES ('NaN')}
+  end
+
+  it 'should quote +Infinity' do
+    inf = 1.0/0.0
+    @db[:test5].insert_sql(:value => inf).must_equal %q{INSERT INTO "test5" ("value") VALUES ('Infinity')}
+  end
+
+  it 'should quote -Infinity' do
+    inf = -1.0/0.0
+    @db[:test5].insert_sql(:value => inf).must_equal %q{INSERT INTO "test5" ("value") VALUES ('-Infinity')}
+  end
+
+  it "Dataset#insert_conflict should respect expressions in the target argument" do
+    @ds = @db[:ic_test]
+    @ds.insert_conflict(:target=>:a).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"a\") DO NOTHING"
+    @ds.insert_conflict(:target=>:c, :conflict_where=>{:c_is_unique=>true}).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"c\") WHERE (\"c_is_unique\" IS TRUE) DO NOTHING"
+    @ds.insert_conflict(:target=>[:b, :c]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", \"c\") DO NOTHING"
+    @ds.insert_conflict(:target=>[:b, Sequel.function(:round, :c)]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", round(\"c\")) DO NOTHING"
+    @ds.insert_conflict(:target=>[:b, Sequel.virtual_row{|o| o.round(:c)}]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", round(\"c\")) DO NOTHING"
+  end
+
+  it "should support creating and dropping foreign tables" do
+    @db.create_table(:t, :foreign=>:f, :options=>{:o=>1}){Integer :a}
+    @db.drop_table(:t, :foreign=>true)
+    @db.sqls.must_equal ['CREATE FOREIGN TABLE "t" ("a" integer) SERVER "f" OPTIONS (o \'1\')',
+      'DROP FOREIGN TABLE "t"']
+  end
+
+  it "#create_function and #drop_function should create and drop functions" do
+    @db.create_function('tf', 'SELECT 1', :returns=>:integer)
+    @db.drop_function('tf')
+    @db.sqls.map{|s| s.gsub(/\s+/, ' ').strip}.must_equal ["CREATE FUNCTION tf() RETURNS integer LANGUAGE SQL AS 'SELECT 1'",
+      'DROP FUNCTION tf()']
+  end
+
+  it "#create_function and #drop_function should support options" do
+    @db.create_function('tf', 'SELECT $1 + $2', :args=>[[:integer, :a], :integer], :replace=>true, :returns=>:integer, :language=>'SQL', :behavior=>:immutable, :strict=>true, :security_definer=>true, :cost=>2, :set=>{:search_path => 'public'})
+    @db.drop_function('tf', :if_exists=>true, :cascade=>true, :args=>[[:integer, :a], :integer])
+    @db.sqls.map{|s| s.gsub(/\s+/, ' ').strip}.must_equal ["CREATE OR REPLACE FUNCTION tf(a integer, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT SECURITY DEFINER COST 2 SET search_path = public AS 'SELECT $1 + $2'",
+      'DROP FUNCTION IF EXISTS tf(a integer, integer) CASCADE']
+  end
+
+  it "#create_language and #drop_language should create and drop languages" do
+    @db.create_language(:plpgsql)
+    @db.create_language(:plpgsql, :replace=>true, :trusted=>true, :handler=>:a, :validator=>:b)
+    @db.drop_language(:plpgsql)
+    @db.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)
+    @db.sqls.map{|s| s.gsub(/\s+/, ' ').strip}.must_equal ['CREATE LANGUAGE plpgsql',
+      'CREATE OR REPLACE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b',
+      'DROP LANGUAGE plpgsql',
+      'DROP LANGUAGE IF EXISTS plpgsql CASCADE']
+  end
+
+  it "#create_schema and #drop_schema should create and drop schemas" do
+    @db.create_schema(:sequel)
+    @db.create_schema(:sequel, :if_not_exists=>true, :owner=>:foo)
+    @db.drop_schema(:sequel)
+    @db.drop_schema(:sequel, :if_exists=>true, :cascade=>true)
+    @db.sqls.must_equal ['CREATE SCHEMA "sequel"',
+      'CREATE SCHEMA IF NOT EXISTS "sequel" AUTHORIZATION "foo"',
+      'DROP SCHEMA "sequel"',
+      'DROP SCHEMA IF EXISTS "sequel" CASCADE']
+  end
+
+  it "#create_trigger and #drop_trigger should create and drop triggers" do
+    @db.create_trigger(:test, :identity, :tf, :each_row=>true)
+    @db.create_trigger(:test, :identity, :tf, :after=>true, :events=>:insert, :args=>[1, 'a'])
+    @db.create_trigger(:test, :identity, :tf, :each_row=>true, :when=> {Sequel[:new][:name] => 'b'})
+    @db.drop_trigger(:test, :identity)
+    @db.drop_trigger(:test, :identity, :if_exists=>true, :cascade=>true)
+    @db.sqls.map{|s| s.gsub(/\s+/, ' ').strip}.must_equal ['CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON "test" FOR EACH ROW EXECUTE PROCEDURE tf()',
+      'CREATE TRIGGER identity AFTER INSERT ON "test" EXECUTE PROCEDURE tf(1, \'a\')',
+      %q{CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON "test" FOR EACH ROW WHEN ("new"."name" = 'b') EXECUTE PROCEDURE tf()},
+      'DROP TRIGGER identity ON "test"',
+      'DROP TRIGGER IF EXISTS identity ON "test" CASCADE']
+  end
+end
+
+describe "MySQL support" do
+  before do
+    @db = Sequel.mock(:host=>'mysql')
+  end
+
+  it "should support spatial indexes" do
+    @db.alter_table(:posts){add_spatial_index [:geom]}
+    @db.sqls.must_equal ['CREATE SPATIAL INDEX `posts_geom_index` ON `posts` (`geom`)']
+  end
+
+  it "should support fulltext indexes and full_text_search" do
+    @db.alter_table(:posts){add_full_text_index :title; add_full_text_index [:title, :body]}
+    @db.sqls.must_equal [ "CREATE FULLTEXT INDEX `posts_title_index` ON `posts` (`title`)", "CREATE FULLTEXT INDEX `posts_title_body_index` ON `posts` (`title`, `body`)" ]
+  end
+
+  it "should support indexes with index type" do
+    @db.alter_table(:posts){add_index :id, :type => :btree}
+    @db.sqls.must_equal ["CREATE INDEX `posts_id_index` USING btree ON `posts` (`id`)"]
+  end
+end
+
+describe "SQLite support" do
+  before do
+    @db = Sequel.mock(:host=>'sqlite')
+  end
+
+  it "should use a string literal for Sequel[:col].as(:alias)" do
+    @db.literal(Sequel[:c].as(:a)).must_equal "`c` AS 'a'"
+  end
+
+  it "should use a string literal for Sequel[:table][:col].as(:alias)" do
+    @db.literal(Sequel[:t][:c].as(:a)).must_equal "`t`.`c` AS 'a'"
+  end
+
+  it "should use a string literal for :column.as(:alias)" do
+    @db.literal(Sequel.as(:c, :a)).must_equal "`c` AS 'a'"
+  end
+
+  it "should use a string literal in the SELECT clause" do
+    @db[:t].select(Sequel[:c].as(:a)).sql.must_equal "SELECT `c` AS 'a' FROM `t`"
+  end
+
+  it "should use a string literal in the FROM clause" do
+    @db[Sequel[:t].as(:a)].sql.must_equal "SELECT * FROM `t` AS 'a'"
+  end
+
+  it "should use a string literal in the JOIN clause" do
+    @db[:t].join_table(:natural, :j, nil, :table_alias=>:a).sql.must_equal "SELECT * FROM `t` NATURAL JOIN `j` AS 'a'"
+  end
+
+  it "should have support for various #transaction modes" do
+    @db.transaction{}
+    @db.transaction(:mode => :immediate){}
+    @db.transaction(:mode => :exclusive){}
+    @db.transaction(:mode => :deferred){}
+    @db.sqls.must_equal ["BEGIN", "COMMIT", "BEGIN IMMEDIATE TRANSACTION", "COMMIT", "BEGIN EXCLUSIVE TRANSACTION", "COMMIT", "BEGIN DEFERRED TRANSACTION", "COMMIT"]
+
+    @db.transaction_mode.must_be_nil
+    @db.transaction_mode = :immediate
+    @db.transaction_mode.must_equal :immediate
+    @db.transaction{}
+    @db.transaction(:mode => :exclusive){}
+    @db.sqls.must_equal ["BEGIN IMMEDIATE TRANSACTION", "COMMIT", "BEGIN EXCLUSIVE TRANSACTION", "COMMIT"]
+  end
+
+  it "should choose a temporary table name that isn't already used when dropping or renaming columns" do
+    exists = [true, true, false]
+    @db.define_singleton_method(:table_exists?){|x| exists.shift}
+    @db.drop_column(:test3, :i)
+    @db.sqls.grep(/ALTER/).must_equal ["ALTER TABLE `test3` RENAME TO `test3_backup2`"]
+
+    exists = [true, true, true, false]
+    @db.rename_column(:test3, :h, :i)
+    @db.sqls.grep(/ALTER/).must_equal ["ALTER TABLE `test3` RENAME TO `test3_backup3`"]
+  end
+end