sequel 3.21.0 → 3.36.0

data/lib/sequel/timezones.rb

@@ -39,6 +39,48 @@ module Sequel
       convert_output_timestamp(v, Sequel.database_timezone)
     end
 
+    # Converts the object to the given +output_timezone+.
+    def convert_output_timestamp(v, output_timezone)
+      if output_timezone
+        if v.is_a?(DateTime)
+          case output_timezone
+          when :utc
+            v.new_offset(0)
+          when :local
+            v.new_offset(local_offset_for_datetime(v))
+          else
+            convert_output_datetime_other(v, output_timezone)
+          end
+        else
+          v.send(output_timezone == :utc ? :getutc : :getlocal)
+        end
+      else
+        v
+      end
+    end
+    
+    # Converts the given object from the given input timezone to the
+    # +application_timezone+ using +convert_input_timestamp+ and
+    # +convert_output_timestamp+.
+    def convert_timestamp(v, input_timezone)
+      begin
+        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)
+          else
+            Time.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)
+        end
+      rescue InvalidValue
+        raise
+      rescue => e
+        raise convert_exception_class(e, InvalidValue)
+      end
+    end
+    
     # Convert the given object into an object of <tt>Sequel.datetime_class</tt> in the
     # +application_timezone+.  Used when coverting datetime/timestamp columns
     # returned by the database.
@@ -103,12 +145,24 @@ module Sequel
           v2
         end
       when Array
-        y, mo, d, h, mi, s = v
+        y, mo, d, h, mi, s, ns, off = v
         if datetime_class == DateTime
-          convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s, 0), input_timezone)
+          s += (defined?(Rational) ? Rational(ns, 1000000000) : ns/1000000000.0) 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)
+          Time.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}
+        if (offset = (v[:offset] || v['offset']))
+          ary << offset
         end
+        convert_input_timestamp(ary, input_timezone)
+        convert_input_timestamp(ary, input_timezone)
       when Time
         if datetime_class == DateTime
           v.respond_to?(:to_datetime) ? v.to_datetime : string_to_datetime(v.iso8601)
@@ -121,8 +175,6 @@ module Sequel
         else
           v.respond_to?(:to_time) ? v.to_time : string_to_datetime(v.to_s)
         end
-      when Date
-        convert_input_timestamp(v.to_s, input_timezone)
       else
         raise InvalidValue, "Invalid convert_input_timestamp type: #{v.inspect}"
       end
@@ -135,39 +187,6 @@ module Sequel
       raise InvalidValue, "Invalid output_timezone: #{output_timezone.inspect}"
     end
     
-    # Converts the object to the given +output_timezone+.
-    def convert_output_timestamp(v, output_timezone)
-      if output_timezone
-        if v.is_a?(DateTime)
-          case output_timezone
-          when :utc
-            v.new_offset(0)
-          when :local
-            v.new_offset(local_offset_for_datetime(v))
-          else
-            convert_output_datetime_other(v, output_timezone)
-          end
-        else
-          v.send(output_timezone == :utc ? :getutc : :getlocal)
-        end
-      else
-        v
-      end
-    end
-    
-    # Converts the given object from the given input timezone to the
-    # +application_timezone+ using +convert_input_timestamp+ and
-    # +convert_output_timestamp+.
-    def convert_timestamp(v, input_timezone)
-      begin
-        convert_output_timestamp(convert_input_timestamp(v, input_timezone), Sequel.application_timezone)
-      rescue InvalidValue
-        raise
-      rescue => e
-        raise convert_exception_class(e, InvalidValue)
-      end
-    end
-    
     # Convert the timezone setter argument.  Returns argument given by default,
     # exists for easier overriding in extensions.
     def convert_timezone_setter_arg(tz)

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 21
+  MINOR = 36
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/db2_spec.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+#Author: Roy L Zuo (roylzuo at gmail dot com)
+#Description: 
+
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+
+require ENV['SEQUEL_DB2_SPEC_REQUIRE'] if ENV['SEQUEL_DB2_SPEC_REQUIRE']
+
+unless defined?(DB2_DB)
+  DB2_DB = Sequel.connect(ENV['SEQUEL_DB2_SPEC_DB']||DB2_URL)
+end
+
+if DB2_DB.table_exists?(:test)
+  DB2_DB.drop_table :test
+end
+INTEGRATION_DB = DB2_DB unless defined?(INTEGRATION_DB)
+
+describe Sequel::Database do
+  before do
+    @db = DB2_DB
+    @db.create_table(:test){String :a}
+    @ds = @db[:test]
+  end
+
+  after do
+    @db.drop_table(:test)
+  end
+  
+  specify "should provide disconnect functionality after preparing a connection" do
+    @ds.prepare(:first, :a).call
+    @db.disconnect
+    @db.pool.size.should == 0
+  end
+
+  specify "should return version correctly" do
+    @db.db2_version.should match(/DB2 v/i)
+  end
+end
+
+describe "Simple Dataset operations" do
+  before do
+    DB2_DB.create_table!(:items) do
+      Integer :id, :primary_key => true
+      Integer :number
+    end
+    @ds = DB2_DB[:items]
+    @ds.insert(:number=>10, :id => 1 )
+  end
+  after do
+    DB2_DB.drop_table(:items)
+  end
+  cspecify "should insert with a primary key specified", :mssql do
+    @ds.insert(:id=>100, :number=>20)
+    @ds.count.should == 2
+    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+  end
+end
+
+describe Sequel::Database do
+  before do
+    @db = DB2_DB
+  end
+  after do
+    @db.drop_table(:items)
+  end
+  specify "should parse primary keys from the schema properly" do
+    @db.create_table!(:items){Integer :number}
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
+    @db.create_table!(:items){primary_key :number}
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number]
+    @db.create_table!(:items){Integer :number1, :null => false; Integer :number2, :null => false; primary_key [:number1, :number2]}
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
+  end
+end
+
+describe "Sequel::IBMDB.convert_smallint_to_bool" do
+  before do
+    @db = DB2_DB
+    @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
+    @ds = @db[:booltest]
+  end
+  after do
+    Sequel::IBMDB.convert_smallint_to_bool = true
+    @db.drop_table(:booltest)
+  end
+  
+  specify "should consider smallint datatypes as boolean if set, but not larger smallints" do
+    @db.schema(:booltest, :reload=>true).first.last[:type].should == :boolean
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].should match /smallint/i
+    Sequel::IBMDB.convert_smallint_to_bool = false
+    @db.schema(:booltest, :reload=>true).first.last[:type].should == :integer
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].should match /smallint/i
+  end
+  
+  specify "should return smallints as bools and integers as integers when set" do
+    Sequel::IBMDB.convert_smallint_to_bool = true
+    @ds.delete
+    @ds << {:b=>true, :i=>10}
+    @ds.all.should == [{:b=>true, :i=>10}]
+    @ds.delete
+    @ds << {:b=>false, :i=>0}
+    @ds.all.should == [{:b=>false, :i=>0}]
+    @ds.delete
+    @ds << {:b=>true, :i=>1}
+    @ds.all.should == [{:b=>true, :i=>1}]
+  end
+
+  specify "should return all smallints as integers when unset" do
+    Sequel::IBMDB.convert_smallint_to_bool = false
+    @ds.delete
+    @ds << {:b=>true, :i=>10}
+    @ds.all.should == [{:b=>1, :i=>10}]
+    @ds.delete
+    @ds << {:b=>false, :i=>0}
+    @ds.all.should == [{:b=>0, :i=>0}]
+    
+    @ds.delete
+    @ds << {:b=>1, :i=>10}
+    @ds.all.should == [{:b=>1, :i=>10}]
+    @ds.delete
+    @ds << {:b=>0, :i=>0}
+    @ds.all.should == [{:b=>0, :i=>0}]
+  end
+end if DB2_DB.adapter_scheme == :ibmdb
+
+describe "Simple Dataset operations in transactions" do
+  before do
+    DB2_DB.create_table!(:items_insert_in_transaction) do
+      Integer :id, :primary_key => true
+      integer :number
+    end
+    @ds = DB2_DB[:items_insert_in_transaction]
+  end
+  after do
+    DB2_DB.drop_table(:items_insert_in_transaction)
+  end
+
+  specify "should insert correctly with a primary key specified inside a transaction" do
+    DB2_DB.transaction do
+      @ds.insert(:id=>100, :number=>20)
+      @ds.count.should == 1
+      @ds.order(:id).all.should == [{:id=>100, :number=>20}]
+    end
+  end
+end

data/spec/adapters/firebird_spec.rb

@@ -247,7 +247,7 @@ end
 describe "A Firebird database" do
   before do
     @db = FIREBIRD_DB
-    @db.drop_table(:posts) rescue nil
+    @db.drop_table?(:posts)
     @db.sqls.clear
   end
 

data/spec/adapters/mssql_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 require ENV['SEQUEL_MSSQL_SPEC_REQUIRE'] if ENV['SEQUEL_MSSQL_SPEC_REQUIRE']
@@ -59,15 +60,44 @@ describe "A MSSQL database" do
   end
 end
 
+# This spec is currently disabled as the SQL Server 2008 R2 Express doesn't support
+# full text searching.  Even if full text searching is supported,
+# you may need to create a full text catalog on the database first via:
+#   CREATE FULLTEXT CATALOG ftscd AS DEFAULT
+describe "MSSQL full_text_search" do
+  before do
+    @db = MSSQL_DB
+    @db.drop_table?(:posts)
+  end
+  after do
+    @db.drop_table?(:posts)
+  end
+  
+  specify "should support fulltext indexes and full_text_search" do
+    log do
+      @db.create_table(:posts){Integer :id, :null=>false; String :title; String :body; index :id, :name=>:fts_id_idx, :unique=>true; full_text_index :title, :key_index=>:fts_id_idx; full_text_index [:title, :body], :key_index=>:fts_id_idx}
+      @db[:posts].insert(:title=>'ruby rails', :body=>'y')
+      @db[:posts].insert(:title=>'sequel', :body=>'ruby')
+      @db[:posts].insert(:title=>'ruby scooby', :body=>'x')
+
+      @db[:posts].full_text_search(:title, 'rails').all.should == [{:title=>'ruby rails', :body=>'y'}]
+      @db[:posts].full_text_search([:title, :body], ['sequel', 'ruby']).all.should == [{:title=>'sequel', :body=>'ruby'}]
+
+      @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'y'}]
+      @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'y'}]
+    end
+  end
+end if false
+
 describe "MSSQL Dataset#join_table" do
   specify "should emulate the USING clause with ON" do
     MSSQL_DB[:items].join(:categories, [:id]).sql.should ==
-      '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))'].
-    should include(MSSQL_DB[:items].join(:categories, [:id1, :id2]).sql)
+      '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]))'].
+      should include(MSSQL_DB[:items].join(:categories, [:id1, :id2]).sql)
     MSSQL_DB[:items___i].join(:categories___c, [:id]).sql.should ==
-      'SELECT * FROM ITEMS AS I INNER JOIN CATEGORIES AS C ON (C.ID = I.ID)'
+      'SELECT * FROM [ITEMS] AS [I] INNER JOIN [CATEGORIES] AS [C] ON ([C].[ID] = [I].[ID])'
   end
 end
 
@@ -79,50 +109,49 @@ describe "MSSQL Dataset#output" do
     @ds = @db[:items]
   end
   after do
-    @db.drop_table(:items)
-    @db.drop_table(:out)
+    @db.drop_table?(:items, :out)
   end
 
   specify "should format OUTPUT clauses without INTO for DELETE statements" do
     @ds.output(nil, [:deleted__name, :deleted__value]).delete_sql.should =~
-      /DELETE FROM ITEMS OUTPUT DELETED.(NAME|VALUE), DELETED.(NAME|VALUE)/
+      /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\]/
     @ds.output(nil, [:deleted.*]).delete_sql.should =~
-      /DELETE FROM ITEMS OUTPUT DELETED.*/
+      /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].*/
   end
   
   specify "should format OUTPUT clauses with INTO for DELETE statements" do
     @ds.output(:out, [:deleted__name, :deleted__value]).delete_sql.should =~
-      /DELETE FROM ITEMS OUTPUT DELETED.(NAME|VALUE), DELETED.(NAME|VALUE) INTO OUT/
+      /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\]/
     @ds.output(:out, {:name => :deleted__name, :value => :deleted__value}).delete_sql.should =~
-      /DELETE FROM ITEMS OUTPUT DELETED.(NAME|VALUE), DELETED.(NAME|VALUE) INTO OUT \((NAME|VALUE), (NAME|VALUE)\)/
+      /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/
   end
 
   specify "should format OUTPUT clauses without INTO for INSERT statements" do
     @ds.output(nil, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).should =~
-      /INSERT INTO ITEMS \((NAME|VALUE), (NAME|VALUE)\) OUTPUT INSERTED.(NAME|VALUE), INSERTED.(NAME|VALUE) VALUES \((N'name'|1), (N'name'|1)\)/
+      /INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] VALUES \((N'name'|1), (N'name'|1)\)/
     @ds.output(nil, [:inserted.*]).insert_sql(:name => "name", :value => 1).should =~
-      /INSERT INTO ITEMS \((NAME|VALUE), (NAME|VALUE)\) OUTPUT INSERTED.* VALUES \((N'name'|1), (N'name'|1)\)/
+      /INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].* VALUES \((N'name'|1), (N'name'|1)\)/
   end
 
   specify "should format OUTPUT clauses with INTO for INSERT statements" do
     @ds.output(:out, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).should =~
-      /INSERT INTO ITEMS \((NAME|VALUE), (NAME|VALUE)\) OUTPUT INSERTED.(NAME|VALUE), INSERTED.(NAME|VALUE) INTO OUT VALUES \((N'name'|1), (N'name'|1)\)/
+      /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 => :inserted__name, :value => :inserted__value}).insert_sql(:name => "name", :value => 1).should =~
-      /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)\)/
+      /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)\)/
   end
 
   specify "should format OUTPUT clauses without INTO for UPDATE statements" do
     @ds.output(nil, [:inserted__name, :deleted__value]).update_sql(:value => 2).should =~
-      /UPDATE ITEMS SET VALUE = 2 OUTPUT (INSERTED.NAME|DELETED.VALUE), (INSERTED.NAME|DELETED.VALUE)/
+      /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\]/
     @ds.output(nil, [:inserted.*]).update_sql(:value => 2).should =~
-      /UPDATE ITEMS SET VALUE = 2 OUTPUT INSERTED.*/
+      /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[INSERTED\].*/
   end
 
   specify "should format OUTPUT clauses with INTO for UPDATE statements" do
     @ds.output(:out, [:inserted__name, :deleted__value]).update_sql(:value => 2).should =~
-      /UPDATE ITEMS SET VALUE = 2 OUTPUT (INSERTED.NAME|DELETED.VALUE), (INSERTED.NAME|DELETED.VALUE) INTO OUT/
+      /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\]/
     @ds.output(:out, {:name => :inserted__name, :value => :deleted__value}).update_sql(:value => 2).should =~
-      /UPDATE ITEMS SET VALUE = 2 OUTPUT (INSERTED.NAME|DELETED.VALUE), (INSERTED.NAME|DELETED.VALUE) INTO OUT \((NAME|VALUE), (NAME|VALUE)\)/
+      /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/
   end
 
   specify "should execute OUTPUT clauses in DELETE statements" do
@@ -163,23 +192,23 @@ describe "MSSQL dataset" do
     end
 
     specify "should prepend UPDATE statements with WITH clause" do
-      @ds1.update_sql(:x => :y).should == 'WITH T AS (SELECT * FROM X) UPDATE T SET X = Y'
-      @ds2.update_sql(:x => :y).should == 'WITH T AS (SELECT * FROM X UNION ALL SELECT * FROM T) UPDATE T SET X = Y'
+      @ds1.update_sql(:x => :y).should == 'WITH [T] AS (SELECT * FROM [X]) UPDATE [T] SET [X] = [Y]'
+      @ds2.update_sql(:x => :y).should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) UPDATE [T] SET [X] = [Y]'
     end
 
     specify "should prepend DELETE statements with WITH clause" do
-      @ds1.filter(:y => 1).delete_sql.should == 'WITH T AS (SELECT * FROM X) DELETE FROM T WHERE (Y = 1)'
-      @ds2.filter(:y => 1).delete_sql.should == 'WITH T AS (SELECT * FROM X UNION ALL SELECT * FROM T) DELETE FROM T WHERE (Y = 1)'
+      @ds1.filter(:y => 1).delete_sql.should == 'WITH [T] AS (SELECT * FROM [X]) DELETE FROM [T] WHERE ([Y] = 1)'
+      @ds2.filter(:y => 1).delete_sql.should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) DELETE FROM [T] WHERE ([Y] = 1)'
     end
 
     specify "should prepend INSERT statements with WITH clause" do
-      @ds1.insert_sql(@db[:t]).should == 'WITH T AS (SELECT * FROM X) INSERT INTO T SELECT * FROM T'
-      @ds2.insert_sql(@db[:t]).should == 'WITH T AS (SELECT * FROM X UNION ALL SELECT * FROM T) INSERT INTO T SELECT * FROM T'
+      @ds1.insert_sql(@db[:t]).should == 'WITH [T] AS (SELECT * FROM [X]) INSERT INTO [T] SELECT * FROM [T]'
+      @ds2.insert_sql(@db[:t]).should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) INSERT INTO [T] SELECT * FROM [T]'
     end
 
     specify "should move WITH clause on joined dataset to top level" do
-      @db[:s].inner_join(@ds1).sql.should == "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.should == "WITH T AS (SELECT * FROM X), S AS (SELECT * FROM Y) SELECT * FROM T INNER JOIN (SELECT * FROM S) AS T1"
+      @db[:s].inner_join(@ds1).sql.should == "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.should == "WITH [T] AS (SELECT * FROM [X]), [S] AS (SELECT * FROM [Y]) SELECT * FROM [T] INNER JOIN (SELECT * FROM [S]) AS [T1]"
     end
 
     describe "on #import" do
@@ -207,10 +236,10 @@ describe "MSSQL dataset" do
         @db[:items].with(:items, @db[:inventory].group(:type)).import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
         @db.import_sqls.should == [
           'BEGIN',
-          "WITH ITEMS AS (SELECT * FROM INVENTORY GROUP BY TYPE) INSERT INTO ITEMS (X, Y) SELECT 1, 2 UNION ALL SELECT 3, 4",
+          "WITH [ITEMS] AS (SELECT * FROM [INVENTORY] GROUP BY [TYPE]) INSERT INTO [ITEMS] ([X], [Y]) SELECT 1, 2 UNION ALL SELECT 3, 4",
           'COMMIT',
           'BEGIN',
-          "WITH ITEMS AS (SELECT * FROM INVENTORY GROUP BY TYPE) INSERT INTO ITEMS (X, Y) SELECT 5, 6",
+          "WITH [ITEMS] AS (SELECT * FROM [INVENTORY] GROUP BY [TYPE]) INSERT INTO [ITEMS] ([X], [Y]) SELECT 5, 6",
           'COMMIT'
         ]
       end
@@ -218,6 +247,23 @@ describe "MSSQL dataset" do
   end
 end
 
+describe "MSSQL::Dataset#import" do
+  before do
+    @db = MSSQL_DB
+    @db.create_table!(:test){primary_key :x; Integer :y}
+    @db.sqls.clear
+    @ds = @db[:test]
+  end
+  after do
+    @db.drop_table?(:test)
+  end
+  
+  specify "#import should work correctly with an arbitrary output value" do
+    @ds.output(nil, [:inserted__y, :inserted__x]).import([:y], [[3], [4]]).should == [{:y=>3, :x=>1}, {:y=>4, :x=>2}]
+    @ds.all.should == [{:x=>1, :y=>3}, {:x=>2, :y=>4}]
+  end
+end
+
 describe "MSSQL joined datasets" do
   before do
     @db = MSSQL_DB
@@ -225,12 +271,12 @@ describe "MSSQL joined datasets" do
 
   specify "should format DELETE statements" do
     @db[:t1].inner_join(:t2, :t1__pk => :t2__pk).delete_sql.should ==
-      "DELETE FROM T1 FROM T1 INNER JOIN T2 ON (T1.PK = T2.PK)"
+      "DELETE FROM [T1] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
   end
 
   specify "should format UPDATE statements" do
     @db[:t1].inner_join(:t2, :t1__pk => :t2__pk).update_sql(:pk => :t2__pk).should ==
-      "UPDATE T1 SET PK = T2.PK FROM T1 INNER JOIN T2 ON (T1.PK = T2.PK)"
+      "UPDATE [T1] SET [PK] = [T2].[PK] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
   end
 end
 
@@ -244,7 +290,7 @@ describe "Offset support" do
     @ds.import [:id, :parent_id], [[1,nil],[2,nil],[3,1],[4,1],[5,3],[6,5]]
   end
   after do
-    @db.drop_table(:i)
+    @db.drop_table?(:i)
   end
   
   specify "should return correct rows" do
@@ -267,8 +313,7 @@ describe "Common Table Expressions" do
     @ds.import [:id, :parent_id], [[1,nil],[2,nil],[3,1],[4,1],[5,3],[6,5]]
   end
   after do
-    @db.drop_table(:i1)
-    @db.drop_table(:i2)
+    @db.drop_table?(:i1, :i2)
   end
 
   specify "using #with should be able to update" do
@@ -338,7 +383,7 @@ describe "MSSSQL::Dataset#insert" do
     @ds = @db[:test5]
   end
   after do
-    @db.drop_table(:test5) rescue nil
+    @db.drop_table?(:test5)
   end
 
   specify "should have insert_select return nil if disable_insert_output is used" do
@@ -369,7 +414,7 @@ describe "MSSSQL::Dataset#into" do
   end
 
   specify "should format SELECT statement" do
-    @db[:t].into(:new).select_sql.should == "SELECT * INTO NEW FROM T"
+    @db[:t].into(:new).select_sql.should == "SELECT * INTO [NEW] FROM [T]"
   end
 
   specify "should select rows into a new table" do
@@ -377,8 +422,7 @@ describe "MSSSQL::Dataset#into" do
     @db[:t].insert(:id => 1, :value => "test")
     @db << @db[:t].into(:new).select_sql
     @db[:new].all.should == [{:id => 1, :value => "test"}]
-    @db.drop_table(:t)
-    @db.drop_table(:new)
+    @db.drop_table?(:t, :new)
   end
 end
 
@@ -387,7 +431,7 @@ describe "A MSSQL database" do
     @db = MSSQL_DB
   end
   after do
-    @db.drop_table(:a)
+    @db.drop_table?(:a)
   end
   
   specify "should handle many existing types for set_column_allow_null" do
@@ -414,7 +458,7 @@ describe "MSSQL::Database#rename_table" do
     MSSQL_DB.create_table! :'foo bar' do
       text :name
     end
-    MSSQL_DB.drop_table :baz rescue nil
+    MSSQL_DB.drop_table? :baz
     proc { MSSQL_DB.rename_table 'foo bar', 'baz' }.should_not raise_error
   end
   
@@ -440,3 +484,61 @@ describe "MSSQL::Dataset#count" do
     MSSQL_DB[:items].select(:name, :value).group(:name, :value).order(:name).count.should == 1
   end
 end
+
+describe "MSSQL::Database#create_table" do
+  specify "should support collate with various other column options" do
+    MSSQL_DB.create_table!(:items){ String :name, :size => 128, :collate => :sql_latin1_general_cp1_ci_as, :default => 'foo', :null => false, :unique => true}
+    MSSQL_DB[:items].insert
+    MSSQL_DB[:items].select_map(:name).should == ["foo"]
+  end
+end
+
+describe "MSSQL::Database#mssql_unicode_strings = false" do
+  before do
+    MSSQL_DB.mssql_unicode_strings = false
+  end
+  after do
+    MSSQL_DB.drop_table?(:items)
+    MSSQL_DB.mssql_unicode_strings = true
+  end
+
+  specify "should work correctly" do
+    MSSQL_DB.create_table!(:items){String :name}
+    MSSQL_DB[:items].mssql_unicode_strings.should == false
+    MSSQL_DB[:items].insert(:name=>'foo')
+    MSSQL_DB[:items].select_map(:name).should == ['foo']
+  end
+
+  specify "should be overridable at the dataset level" do
+    MSSQL_DB.create_table!(:items){String :name}
+    ds = MSSQL_DB[:items]
+    ds.mssql_unicode_strings.should == false
+    ds.mssql_unicode_strings = true
+    ds.mssql_unicode_strings.should == true
+    ds.insert(:name=>'foo')
+    ds.select_map(:name).should == ['foo']
+  end
+end
+
+describe "A MSSQL database adds index with include" do
+  before :all do
+    @table_name = :test_index_include
+    @db = MSSQL_DB
+    @db.create_table! @table_name do
+      integer :col1
+      integer :col2
+      integer :col3
+    end
+  end
+
+  after :all do
+    @db.drop_table? @table_name
+  end
+
+  cspecify "should be able add index with include" do
+    @db.alter_table @table_name do
+      add_index [:col1], :include => [:col2,:col3]
+    end
+    @db.indexes(@table_name).should have_key("#{@table_name}_col1_index".to_sym)
+  end
+end