sequel 4.49.0 → 5.0.0

data/lib/sequel/timezones.rb

@@ -54,7 +54,7 @@ module Sequel
             convert_output_datetime_other(v, output_timezone)
           end
         else
-          v.send(output_timezone == :utc ? :getutc : :getlocal)
+          v.public_send(output_timezone == :utc ? :getutc : :getlocal)
         end
       else
         v
@@ -69,9 +69,9 @@ module Sequel
         if v.is_a?(Date) && !v.is_a?(DateTime)
           # Dates handled specially as they are assumed to already be in the application_timezone
           if datetime_class == DateTime
-            DateTime.civil(v.year, v.month, v.day, 0, 0, 0, application_timezone == :local ? (defined?(Rational) ? Rational(Time.local(v.year, v.month, v.day).utc_offset, 86400) : Time.local(v.year, v.month, v.day).utc_offset/86400.0) : 0)
+            DateTime.civil(v.year, v.month, v.day, 0, 0, 0, application_timezone == :local ? Rational(Time.local(v.year, v.month, v.day).utc_offset, 86400) : 0)
           else
-            Time.send(application_timezone == :utc ? :utc : :local, v.year, v.month, v.day)
+            Time.public_send(application_timezone == :utc ? :utc : :local, v.year, v.month, v.day)
           end
         else
           convert_output_timestamp(convert_input_timestamp(v, input_timezone), application_timezone)
@@ -149,14 +149,14 @@ module Sequel
       when Array
         y, mo, d, h, mi, s, ns, off = v
         if datetime_class == DateTime
-          s += (defined?(Rational) ? Rational(ns, 1000000000) : ns/1000000000.0) if ns
+          s += Rational(ns, 1000000000) if ns
           if off
             DateTime.civil(y, mo, d, h, mi, s, off)
           else
             convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s), input_timezone)
           end
         else
-          Time.send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
+          Time.public_send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
         end
       when Hash
         ary = [:year, :month, :day, :hour, :minute, :second, :nanos].map{|x| (v[x] || v[x.to_s]).to_i}
@@ -167,29 +167,15 @@ module Sequel
         convert_input_timestamp(ary, input_timezone)
       when Time
         if datetime_class == DateTime
-          if v.respond_to?(:to_datetime)
-            v.to_datetime
-          else
-          # :nocov:
-            # SEQUEL5: Remove
-            # Ruby 1.8 code, %N not available and %z broken on Windows
-            offset_hours, offset_minutes = (v.utc_offset/60).divmod(60)
-            string_to_datetime(v.strftime("%Y-%m-%dT%H:%M:%S") << sprintf(".%06i%+03i%02i", v.usec, offset_hours, offset_minutes))
-          # :nocov:
-          end
+          v.to_datetime
         else
           v
         end
       when DateTime
         if datetime_class == DateTime
           v
-        elsif v.respond_to?(:to_time)
-          v.to_time
         else
-        # :nocov:
-        # SEQUEL5: Remove
-          string_to_datetime(v.strftime("%FT%T.%N%z"))
-        # :nocov:
+          v.to_time
         end
       else
         raise InvalidValue, "Invalid convert_input_timestamp type: #{v.inspect}"
@@ -217,7 +203,7 @@ module Sequel
     # Caches offset conversions to avoid excess Rational math.
     def time_offset_to_datetime_offset(offset_secs)
       @local_offsets ||= {}
-      @local_offsets[offset_secs] ||= respond_to?(:Rational, true) ? Rational(offset_secs, 60*60*24) : offset_secs/60/60/24.0
+      @local_offsets[offset_secs] ||= Rational(offset_secs, 86400)
     end
   end
 

data/lib/sequel/version.rb

@@ -2,10 +2,10 @@
 
 module Sequel
   # The major version of Sequel.  Only bumped for major changes.
-  MAJOR = 4
+  MAJOR = 5
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 49
+  MINOR = 0
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapter_spec.rb

@@ -1,4 +1,4 @@
 if !ARGV.empty? && ARGV.first != 'none'
-  require "./spec/adapters/#{ARGV.first}_spec.rb"
+  require_relative "adapters/#{ARGV.first}_spec"
 end
 Dir['./spec/integration/*_test.rb'].each{|f| require f}

data/spec/adapters/db2_spec.rb

@@ -1,6 +1,6 @@
 SEQUEL_ADAPTER_TEST = :db2
 
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative 'spec_helper'
 
 if DB.table_exists?(:test)
   DB.drop_table(:test)
@@ -28,44 +28,6 @@ describe Sequel::Database do
   end
 end
 
-# SEQUEL5: Remove
-describe "Simple Dataset operations" do
-  before(:all) do
-    deprecated do
-      Sequel::DB2.use_clob_as_blob = true
-    end
-    DB.send(:remove_instance_variable, :@use_clob_as_blob) if DB.send(:instance_variable_defined?, :@use_clob_as_blob)
-    DB.create_table!(:items) do
-      Integer :id, :primary_key => true
-      Integer :number
-      column  :bin_string, 'varchar(20) for bit data'
-      column  :bin_clob, 'clob'
-    end
-    @ds = DB[:items]
-  end
-  after(:each) do
-    @ds.delete
-  end
-  after(:all) do
-    deprecated do
-      Sequel::DB2.use_clob_as_blob = false
-    end
-    DB.send(:remove_instance_variable, :@use_clob_as_blob) if DB.send(:instance_variable_defined?, :@use_clob_as_blob)
-    DB.drop_table(:items)
-  end
-
-  it "should insert with a primary key specified" do
-    @ds.insert(:id => 1,   :number => 10)
-    @ds.insert(:id => 100, :number => 20)
-    @ds.select_hash(:id, :number).must_equal(1 => 10, 100 => 20)
-  end
-
-  it "should insert into binary columns" do
-    @ds.insert(:id => 1, :bin_string => Sequel.blob("\1"), :bin_clob => Sequel.blob("\2"))
-    @ds.select(:bin_string, :bin_clob).first.must_equal(:bin_string => "\1", :bin_clob => "\2")
-  end
-end
-
 describe "Simple Dataset operations" do
   before(:all) do
     DB.use_clob_as_blob = true
@@ -126,69 +88,6 @@ describe Sequel::Database do
   end
 end
 
-# SEQUEL5: remove
-describe "Sequel::IBMDB.convert_smallint_to_bool" do
-  before do
-    @db = DB
-    @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
-    @ds = @db[:booltest]
-  end
-  after do
-    deprecated do
-      Sequel::IBMDB.convert_smallint_to_bool = true
-    end
-    @db.drop_table(:booltest)
-  end
-  
-  deprecated "should consider smallint datatypes as boolean if set, but not larger smallints" do
-    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :boolean
-    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-    Sequel::IBMDB.convert_smallint_to_bool = false
-    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :integer
-    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-  end
-  
-  deprecated "should return smallints as bools and integers as integers when set" do
-    Sequel::IBMDB.convert_smallint_to_bool = true
-    @ds.delete
-    @ds.insert(:b=>true, :i=>10)
-    @ds.all.must_equal [{:b=>true, :i=>10}]
-    @ds.delete
-    @ds.insert(:b=>false, :i=>0)
-    @ds.all.must_equal [{:b=>false, :i=>0}]
-    @ds.delete
-    @ds.insert(:b=>true, :i=>1)
-    @ds.all.must_equal [{:b=>true, :i=>1}]
-
-    @ds = @ds.with_convert_smallint_to_bool(false)
-    @ds.delete
-    @ds.insert(:b=>true, :i=>10)
-    @ds.all.must_equal [{:b=>1, :i=>10}]
-  end
-
-  deprecated "should return all smallints as integers when unset" do
-    Sequel::IBMDB.convert_smallint_to_bool = false
-    @ds.delete
-    @ds.insert(:b=>true, :i=>10)
-    @ds.all.must_equal [{:b=>1, :i=>10}]
-    @ds.delete
-    @ds.insert(:b=>false, :i=>0)
-    @ds.all.must_equal [{:b=>0, :i=>0}]
-    
-    @ds.delete
-    @ds.insert(:b=>1, :i=>10)
-    @ds.all.must_equal [{:b=>1, :i=>10}]
-    @ds.delete
-    @ds.insert(:b=>0, :i=>0)
-    @ds.all.must_equal [{:b=>0, :i=>0}]
-
-    @ds = @ds.with_convert_smallint_to_bool(true)
-    @ds.delete
-    @ds.insert(:b=>true, :i=>10)
-    @ds.all.must_equal [{:b=>true, :i=>10}]
-  end
-end if DB.adapter_scheme == :ibmdb
-
 describe "Sequel::IBMDB::Database#convert_smallint_to_bool" do
   before do
     @db = DB
@@ -196,7 +95,7 @@ describe "Sequel::IBMDB::Database#convert_smallint_to_bool" do
     @ds = @db[:booltest]
   end
   after do
-    @db.convert_smallint_to_bool = nil # SEQUEL5: true
+    @db.convert_smallint_to_bool = true
     @db.drop_table(:booltest)
   end
   

data/spec/adapters/mssql_spec.rb

@@ -1,15 +1,6 @@
 SEQUEL_ADAPTER_TEST = :mssql
 
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-
-def DB.sqls
-  (@sqls ||= [])
-end
-logger = Object.new
-def logger.method_missing(m, msg)
-  DB.sqls << msg
-end
-DB.loggers = [logger]
+require_relative 'spec_helper'
 
 describe "A MSSQL database" do
   before do
@@ -119,55 +110,59 @@ describe "MSSQL full_text_search" do
   end
 end if false
 
-describe "MSSQL Dataset#join_table" do
-  it "should emulate the USING clause with ON" do
-    DB[:items].join(:categories, [:id]).sql.must_equal 'SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON ([CATEGORIES].[ID] = [ITEMS].[ID])'
-    ['SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON (([CATEGORIES].[ID1] = [ITEMS].[ID1]) AND ([CATEGORIES].[ID2] = [ITEMS].[ID2]))',
-      'SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON (([CATEGORIES].[ID2] = [ITEMS].[ID2]) AND ([CATEGORIES].[ID1] = [ITEMS].[ID1]))'].
-      must_include(DB[:items].join(:categories, [:id1, :id2]).sql)
-    DB[Sequel[:items].as(:i)].join(Sequel[:categories].as(:c), [:id]).sql.must_equal 'SELECT * FROM [ITEMS] AS [I] INNER JOIN [CATEGORIES] AS [C] ON ([C].[ID] = [I].[ID])'
-  end
-end
-
 describe "MSSQL Dataset#output" do
-  before do
+  before(:all) do
     @db = DB
     @db.create_table!(:items){String :name; Integer :value}
     @db.create_table!(:out){String :name; Integer :value}
     @ds = @db[:items]
   end
   after do
+    @ds.delete
+    @db[:out].delete
+  end
+  after(:all) do
     @db.drop_table?(:items, :out)
   end
 
-  it "should format OUTPUT clauses without INTO for DELETE statements" do
-    @ds.output(nil, [Sequel[:deleted][:name], Sequel[:deleted][:value]]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\]/)
-    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:deleted)]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].*/)
+  it "should handle OUTPUT clauses without INTO for DELETE statements" do
+    @ds.insert(:name=>'a', :value=>1)
+    @ds.output(nil, [Sequel[:deleted][:name], Sequel[:deleted][:value]]).with_sql(:delete_sql).all.must_equal [{:name=>"a", :value=>1}]
+    @ds.insert(:name=>'a', :value=>1)
+    @ds.output(nil, [Sequel[:deleted][:name]]).with_sql(:delete_sql).all.must_equal [{:name=>"a"}]
+    @ds.insert(:name=>'a', :value=>1)
+    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:deleted)]).with_sql(:delete_sql).all.must_equal [{:name=>"a", :value=>1}]
   end
   
-  it "should format OUTPUT clauses with INTO for DELETE statements" do
-    @ds.output(:out, [Sequel[:deleted][:name], Sequel[:deleted][:value]]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\]/)
-    @ds.output(:out, {:name => Sequel[:deleted][:name], :value => Sequel[:deleted][:value]}).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/)
+  it "should handle OUTPUT clauses with INTO for DELETE statements" do
+    @ds.insert(:name=>'a', :value=>1)
+    @ds.output(:out, {:name => Sequel[:deleted][:name], :value => Sequel[:deleted][:value]}).delete
+    @db[:out].all.must_equal [{:name=>"a", :value=>1}]
   end
 
-  it "should format OUTPUT clauses without INTO for INSERT statements" do
-    @ds.output(nil, [Sequel[:inserted][:name], Sequel[:inserted][:value]]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] VALUES \((N'name'|1), (N'name'|1)\)/)
-    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].* VALUES \((N'name'|1), (N'name'|1)\)/)
+  it "should handle OUTPUT clauses without INTO for INSERT statements" do
+    @ds.output(nil, [Sequel[:inserted][:name], Sequel[:inserted][:value]]).with_sql(:insert_sql, :name => "name", :value => 1).all.must_equal [{:name=>"name", :value=>1}]
+    @ds.all.must_equal [{:name=>"name", :value=>1}]
   end
 
-  it "should format OUTPUT clauses with INTO for INSERT statements" do
-    @ds.output(:out, [Sequel[:inserted][:name], Sequel[:inserted][:value]]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \((\[NAME\]|\[VALUE\]), (\[NAME\]|\[VALUE\])\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] VALUES \((N'name'|1), (N'name'|1)\)/)
-    @ds.output(:out, {:name => Sequel[:inserted][:name], :value => Sequel[:inserted][:value]}).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) VALUES \((N'name'|1), (N'name'|1)\)/)
+  it "should handle OUTPUT clauses with INTO for INSERT statements" do
+    @ds.output(:out, {:name => Sequel[:inserted][:name], :value => Sequel[:inserted][:value]}).insert(:name => "name", :value => 1)
+    @db[:out].all.must_equal [{:name=>"name", :value=>1}]
   end
 
-  it "should format OUTPUT clauses without INTO for UPDATE statements" do
-    @ds.output(nil, [Sequel[:inserted][:name], Sequel[:deleted][:value]]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\]/)
-    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[INSERTED\].*/)
+  it "should handle OUTPUT clauses without INTO for UPDATE statements" do
+    @ds.insert(:name=>'a', :value=>1)
+    @ds.output(nil, [Sequel[:inserted][:name], Sequel[:deleted][:value]]).with_sql(:update_sql, :value => 2).all.must_equal [{:name=>"a", :value=>1}]
+    @ds.all.must_equal [{:name=>"a", :value=>2}]
+    @ds.output(nil, [Sequel[:inserted][:name]]).with_sql(:update_sql, :value => 3).all.must_equal [{:name=>"a"}]
+    @ds.all.must_equal [{:name=>"a", :value=>3}]
+    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).with_sql(:update_sql, :value => 4).all.must_equal [{:name=>"a", :value=>4}]
   end
 
-  it "should format OUTPUT clauses with INTO for UPDATE statements" do
-    @ds.output(:out, [Sequel[:inserted][:name], Sequel[:deleted][:value]]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\]/)
-    @ds.output(:out, {:name => Sequel[:inserted][:name], :value => Sequel[:deleted][:value]}).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/)
+  it "should handle OUTPUT clauses with INTO for UPDATE statements" do
+    @ds.insert(:name=>'a', :value=>1)
+    @ds.output(:out, {:name => Sequel[:inserted][:name], :value => Sequel[:deleted][:value]}).update(:value => 2)
+    @db[:out].all.must_equal [{:name=>"a", :value=>1}]
   end
 
   it "should execute OUTPUT clauses in DELETE statements" do
@@ -196,38 +191,59 @@ describe "MSSQL Dataset#output" do
 end
 
 describe "MSSQL dataset using #with and #with_recursive" do
-  before do
+  before(:all) do
     @db = DB
-    @ds = DB[:t]
-      @ds1 = @ds.with(:t, @db[:x])
-      @ds2 = @ds.with_recursive(:t, @db[:x], @db[:t])
+    @ds = DB[:x]
+    @ds1 = @ds.with(:t, @db[:x])
+    @ds2 = @ds.with_recursive(:t, @db[:x], @db[:t].where(false))
+    @db.create_table!(:x){Integer :v; Integer :y}
+  end
+  before do
+    @db[:x].insert(:v=>1, :y=>2)
+  end
+  after do
+    @db[:x].delete
+  end
+  after(:all) do
+    @db.drop_table?(:x)
   end
 
-  it "should prepend UPDATE statements with WITH clause" do
-    @ds1.update_sql(:x => :y).must_equal 'WITH [T] AS (SELECT * FROM [X]) UPDATE [T] SET [X] = [Y]'
-    @ds2.update_sql(:x => :y).must_equal 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) UPDATE [T] SET [X] = [Y]'
+  it "should handle CTEs in UPDATE queries" do
+    @ds1.update(:v => @db[:t].select(:y))
+    @ds.all.must_equal [{:v=>2, :y=>2}]
+    @ds2.update(:v => Sequel.+(@db[:t].select(:y), 1))
+    @ds.all.must_equal [{:v=>3, :y=>2}]
   end
 
-  it "should prepend DELETE statements with WITH clause" do
-    @ds1.filter(:y => 1).delete_sql.must_equal 'WITH [T] AS (SELECT * FROM [X]) DELETE FROM [T] WHERE ([Y] = 1)'
-    @ds2.filter(:y => 1).delete_sql.must_equal 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) DELETE FROM [T] WHERE ([Y] = 1)'
+  it "should handle CTEs in DELETE queries" do
+    @ds1.where(@db[:t].select(:y)=>1).delete
+    @ds.all.must_equal [{:v=>1, :y=>2}]
+    @ds1.where(@db[:t].select(:y)=>2).delete
+    @ds.all.must_equal []
+
+    @db[:x].insert(:v=>1, :y=>2)
+    @ds2.where(@db[:t].select(:y)=>1).delete
+    @ds.all.must_equal [{:v=>1, :y=>2}]
+    @ds2.where(@db[:t].select(:y)=>2).delete
+    @ds.all.must_equal []
   end
 
-  it "should prepend INSERT statements with WITH clause" do
-    @ds1.insert_sql(@db[:t]).must_equal 'WITH [T] AS (SELECT * FROM [X]) INSERT INTO [T] SELECT * FROM [T]'
-    @ds2.insert_sql(@db[:t]).must_equal 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) INSERT INTO [T] SELECT * FROM [T]'
+  it "should handle CTEs in INSERT queries" do
+    @ds1.insert(:v => @db[:t].select(:y), :y => @db[:t].select(:v))
+    @ds.select_order_map([:v, :y]).must_equal [[1, 2], [2, 1]]
+    @ds1.insert(:v => Sequel.+(@db[:t].where(:v=>1).select(:y), 2), :y => Sequel.+(@db[:t].where(:y=>1).select(:v), 3))
+    @ds.select_order_map([:v, :y]).must_equal [[1, 2], [2, 1], [4, 5]]
   end
 
-  it "should move WITH clause on joined dataset to top level" do
-    @db[:s].inner_join(@ds1).sql.must_equal "WITH [T] AS (SELECT * FROM [X]) SELECT * FROM [S] INNER JOIN (SELECT * FROM [T]) AS [T1]"
-    @ds1.inner_join(@db[:s].with(:s, @db[:y])).sql.must_equal "WITH [T] AS (SELECT * FROM [X]), [S] AS (SELECT * FROM [Y]) SELECT * FROM [T] INNER JOIN (SELECT * FROM [S]) AS [T1]"
+  it "should handle WITH clause on joined dataset" do
+    @ds.cross_join(@ds1.select(Sequel[:v].as(:v1), Sequel[:y].as(:y1))).all.must_equal [{:v=>1, :y=>2, :v1=>1, :y1=>2}]
+    @ds.cross_join(@ds2.select(Sequel[:v].as(:v1), Sequel[:y].as(:y1))).all.must_equal [{:v=>1, :y=>2, :v1=>1, :y1=>2}]
   end
 end
 
 describe "MSSQL::Dataset#import" do
   before do
     @db = DB
-    @db.sqls.clear
     @ds = @db[:test]
   end
   after do
@@ -250,14 +266,21 @@ end
 describe "MSSQL joined datasets" do
   before do
     @db = DB
+    @db.create_table!(:a){Integer :v}
+    @db[:a].insert(:v=>1)
+  end
+  after do
+    @db.drop_table?(:a)
   end
 
-  it "should format DELETE statements" do
-    @db[:t1].inner_join(:t2, Sequel[:t1][:pk] => Sequel[:t2][:pk]).delete_sql.must_equal "DELETE FROM [T1] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
+  it "should handle DELETE statements" do
+    @db[:a].inner_join(Sequel[:a].as(:b), :v=>:v).delete.must_equal 1
+    @db[:a].empty?.must_equal true
   end
 
-  it "should format UPDATE statements" do
-    @db[:t1].inner_join(:t2, Sequel[:t1][:pk] => Sequel[:t2][:pk]).update_sql(:pk => Sequel[:t2][:pk]).must_equal "UPDATE [T1] SET [PK] = [T2].[PK] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
+  it "should handle UPDATE statements" do
+    @db[:a].inner_join(Sequel[:a].as(:b), :v=>:v).update(:v=>2).must_equal 1
+    @db[:a].all.must_equal [{:v=>2}]
   end
 end
 
@@ -312,7 +335,7 @@ describe "Update/Delete on limited datasets" do
     proc{@ds.limit(1, 1).update(:id=>Sequel[:id]+10)}.must_raise Sequel::InvalidOperation
     proc{@ds.order(:id).limit(1).update(:id=>Sequel[:id]+10)}.must_raise Sequel::InvalidOperation
     proc{@ds.order(:id).limit(1).delete}.must_raise Sequel::InvalidOperation
-  end if false # SEQUEL5 
+  end
 end if DB.dataset.send(:is_2012_or_later?)
 
 describe "Common Table Expressions" do
@@ -395,7 +418,6 @@ describe "MSSSQL::Dataset#insert" do
       String :name, :size => 20
       column :value, 'varbinary(max)'
     end
-    @db.sqls.clear
     @ds = @db[:test5]
   end
   after do
@@ -435,18 +457,17 @@ end
 describe "MSSSQL::Dataset#into" do
   before do
     @db = DB
+    @db.drop_table?(:t, :new)
   end
-
-  it "should format SELECT statement" do
-    @db[:t].into(:new).select_sql.must_equal "SELECT * INTO [NEW] FROM [T]"
+  after do
+    @db.drop_table?(:t, :new)
   end
 
   it "should select rows into a new table" do
     @db.create_table!(:t) {Integer :id; String :value}
     @db[:t].insert(:id => 1, :value => "test")
-    @db << @db[:t].into(:new).select_sql
+    @db[:t].into(:new).with_sql(:select_sql).insert
     @db[:new].all.must_equal [{:id => 1, :value => "test"}]
-    @db.drop_table?(:t, :new)
   end
 end
 
@@ -564,7 +585,7 @@ describe "A MSSQL database adds index with include" do
     @db.alter_table @table_name do
       add_index [:col1], :include => [:col2,:col3]
     end
-    @db.indexes(@table_name).keys.must_include("#{@table_name}_col1_index".to_sym)
+    @db.indexes(@table_name).keys.must_include(:"#{@table_name}_col1_index")
   end
 end