sequel 3.4.0 → 3.5.0

data/lib/sequel/timezones.rb

@@ -0,0 +1,161 @@
+module Sequel
+  # The offset of the current time zone from UTC, in seconds.
+  LOCAL_DATETIME_OFFSET_SECS = Time.now.utc_offset
+  
+  # The offset of the current time zone from UTC, as a fraction of a day.
+  LOCAL_DATETIME_OFFSET = respond_to?(:Rational, true) ? Rational(LOCAL_DATETIME_OFFSET_SECS, 60*60*24) : LOCAL_DATETIME_OFFSET_SECS/60/60/24.0
+  
+  @application_timezone = nil
+  @database_timezone = nil
+  @typecast_timezone = nil
+  
+  module Timezones
+    attr_reader :application_timezone, :database_timezone, :typecast_timezone
+  
+    %w'application database typecast'.each do |t|
+      class_eval("def #{t}_timezone=(tz); @#{t}_timezone = convert_timezone_setter_arg(tz) end", __FILE__, __LINE__)
+    end
+  
+    # Convert the given Time/DateTime object into the database timezone, used when
+    # literalizing objects in an SQL string.
+    def application_to_database_timestamp(v)
+      convert_output_timestamp(v, Sequel.database_timezone)
+    end
+
+    # Convert the given object into an object of Sequel.datetime_class in the
+    # application_timezone.  Used when coverting datetime/timestamp columns
+    # returned by the database.
+    def database_to_application_timestamp(v)
+      convert_timestamp(v, Sequel.database_timezone)
+    end
+  
+    # Sets the database, application, and typecasting timezones to the given timezone. 
+    def default_timezone=(tz)
+      self.database_timezone = tz
+      self.application_timezone = tz
+      self.typecast_timezone = tz
+    end
+  
+    # Convert the given object into an object of Sequel.datetime_class in the
+    # application_timezone.  Used when typecasting values when assigning them
+    # to model datetime attributes.
+    def typecast_to_application_timestamp(v)
+      convert_timestamp(v, Sequel.typecast_timezone)
+    end
+
+    private
+
+    # Convert the given DateTime to the given input_timezone, keeping the
+    # same time and just modifying the timezone.
+    def convert_input_datetime_no_offset(v, input_timezone)
+      case input_timezone
+      when :utc
+        v# DateTime assumes UTC if no offset is given
+      when :local
+        v.new_offset(LOCAL_DATETIME_OFFSET) - LOCAL_DATETIME_OFFSET
+      else
+        convert_input_datetime_other(v, input_timezone)
+      end
+    end
+    
+    # Convert the given DateTime to the given input_timezone that is not supported
+    # by default (such as nil, :local, or :utc).  Raises an error by default.
+    # Can be overridden in extensions.
+    def convert_input_datetime_other(v, input_timezone)
+      raise InvalidValue, "Invalid input_timezone: #{input_timezone.inspect}"
+    end
+    
+    # Converts the object from a String, Array, Date, DateTime, or Time into an
+    # instance of Sequel.datetime_class.  If given an array or a string that doesn't
+    # contain an offset, assume that the array/string is already in the given input_timezone.
+    def convert_input_timestamp(v, input_timezone)
+      case v
+      when String
+        v2 = Sequel.string_to_datetime(v)
+        if !input_timezone || Date._parse(v).has_key?(:offset)
+          v2
+        else
+          # Correct for potentially wrong offset if string doesn't include offset
+          if v2.is_a?(DateTime)
+            v2 = convert_input_datetime_no_offset(v2, input_timezone)
+          else
+            # Time assumes local time if no offset is given
+            v2 = v2.getutc + LOCAL_DATETIME_OFFSET_SECS if input_timezone == :utc
+          end
+          v2
+        end
+      when Array
+        y, mo, d, h, mi, s = v
+        if datetime_class == DateTime
+          convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s, 0), input_timezone)
+        else
+          Time.send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s)
+        end
+      when Time
+        if datetime_class == DateTime
+          v.respond_to?(:to_datetime) ? v.to_datetime : string_to_datetime(v.iso8601)
+        else
+          v
+        end
+      when DateTime
+        if datetime_class == DateTime
+          v
+        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
+    end
+    
+    # Convert the given DateTime to the given output_timezone that is not supported
+    # by default (such as nil, :local, or :utc).  Raises an error by default.
+    # Can be overridden in extensions.
+    def convert_output_datetime_other(v, output_timezone)
+      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_DATETIME_OFFSET)
+          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)
+      tz
+    end
+  end
+
+  extend Timezones
+end

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 3
-  MINOR = 4
+  MINOR = 5
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/mssql_spec.rb

@@ -0,0 +1,262 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+unless defined?(MSSQL_DB)
+  MSSQL_URL = 'jdbc:sqlserver://localhost;integratedSecurity=true;database=sandbox' unless defined? MSSQL_URL
+  MSSQL_DB = Sequel.connect(ENV['SEQUEL_MSSQL_SPEC_DB']||MSSQL_URL)
+end
+INTEGRATION_DB = MSSQL_DB unless defined?(INTEGRATION_DB)
+
+context "A MSSQL database" do
+  before do
+    @db = MSSQL_DB
+  end
+
+  cspecify "should be able to read fractional part of timestamp", :odbc do
+    rs = @db["select getutcdate() as full_date, cast(datepart(millisecond, getutcdate()) as int) as milliseconds"].first
+    rs[:milliseconds].should == rs[:full_date].usec/1000
+  end
+
+  cspecify "should be able to write fractional part of timestamp", :odbc do
+    t = Time.utc(2001, 12, 31, 23, 59, 59, 997000)
+    (t.usec/1000).should == @db["select cast(datepart(millisecond, ?) as int) as milliseconds", t].get
+  end
+  
+  specify "should not raise an error when getting the server version" do
+    proc{@db.server_version}.should_not raise_error
+    proc{@db.dataset.server_version}.should_not raise_error
+  end
+end
+
+context "MSSQL Dataset#output" do
+  before do
+    @db = MSSQL_DB
+    @db.create_table!(:items){String :name; Integer :value}
+    @db.create_table!(:out){String :name; Integer :value}
+    @ds = @db[:items]
+  end
+  after do
+    @db.drop_table(:items)
+    @db.drop_table(:out)
+  end
+
+  specify "should format OUTPUT clauses 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/
+    @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)\)/
+  end
+
+  specify "should format OUTPUT clauses 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)\)/
+    @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)\)/
+  end
+
+  specify "should format OUTPUT clauses 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/
+    @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)\)/
+  end
+
+  specify "should execute OUTPUT clauses in DELETE statements" do
+    @ds.insert(:name => "name", :value => 1)
+    @ds.output(:out, [:deleted__name, :deleted__value]).delete
+    @db[:out].all.should == [{:name => "name", :value => 1}]
+    @ds.insert(:name => "name", :value => 2)
+    @ds.output(:out, {:name => :deleted__name, :value => :deleted__value}).delete
+    @db[:out].all.should == [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
+  end
+
+  specify "should execute OUTPUT clauses in INSERT statements" do
+    @ds.output(:out, [:inserted__name, :inserted__value]).insert(:name => "name", :value => 1)
+    @db[:out].all.should == [{:name => "name", :value => 1}]
+    @ds.output(:out, {:name => :inserted__name, :value => :inserted__value}).insert(:name => "name", :value => 2)
+    @db[:out].all.should == [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
+  end
+
+  specify "should execute OUTPUT clauses in UPDATE statements" do
+    @ds.insert(:name => "name", :value => 1)
+    @ds.output(:out, [:inserted__name, :deleted__value]).update(:value => 2)
+    @db[:out].all.should == [{:name => "name", :value => 1}]
+    @ds.output(:out, {:name => :inserted__name, :value => :deleted__value}).update(:value => 3)
+    @db[:out].all.should == [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
+  end
+end
+
+context "MSSQL dataset" do
+  before do
+    @db = MSSQL_DB
+    @ds = MSSQL_DB[:t]
+  end
+
+  context "using #with and #with_recursive" do
+    before do
+      @ds1 = @ds.with(:t, @db[:x])
+      @ds2 = @ds.with_recursive(:t, @db[:x], @db[:t])
+    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'
+    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)'
+    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'
+    end
+
+    context "on #import" do
+      before do
+        @db = @db.clone
+        class << @db
+          attr_reader :sqls
+
+          def execute(sql, opts={})
+            @sqls ||= []
+            @sqls << sql
+          end
+          alias execute_dui execute
+
+          def transaction(opts={})
+            @sqls ||= []
+            @sqls << 'BEGIN'
+            yield
+            @sqls << 'COMMIT'
+          end
+        end
+      end
+
+      specify "should prepend INSERT statements with WITH clause" do
+        @db[:items].with(:items, @db[:inventory].group(:type)).import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
+        @db.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",
+          'COMMIT',
+          'BEGIN',
+          "WITH ITEMS AS (SELECT * FROM INVENTORY GROUP BY TYPE) INSERT INTO ITEMS (X, Y) SELECT 5, 6",
+          'COMMIT'
+        ]
+      end
+    end
+  end
+end
+
+context "MSSQL joined datasets" do
+  before do
+    @db = MSSQL_DB
+  end
+
+  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)"
+  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)"
+  end
+end
+
+describe "Offset support" do
+  before do
+    @db = MSSQL_DB
+    @db.create_table!(:i){Integer :id; Integer :parent_id}
+    @ds = @db[:i].order(:id)
+    @hs = []
+    @ds.row_proc = proc{|r| @hs << r.dup; r[:id] *= 2; r[:parent_id] *= 3; r}
+    @ds.import [:id, :parent_id], [[1,nil],[2,nil],[3,1],[4,1],[5,3],[6,5]]
+  end
+  after do
+    @db.drop_table(:i)
+  end
+  
+  specify "should return correct rows" do
+    @ds.limit(2, 2).all.should == [{:id=>6, :parent_id=>3}, {:id=>8, :parent_id=>3}]
+  end
+  
+  specify "should not include offset column in hashes passed to row_proc" do
+    @ds.limit(2, 2).all
+    @hs.should == [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}]
+  end
+end
+
+describe "Common Table Expressions" do
+  before do
+    @db = MSSQL_DB
+    @db.create_table!(:i1){Integer :id; Integer :parent_id}
+    @db.create_table!(:i2){Integer :id; Integer :parent_id}
+    @ds = @db[:i1]
+    @ds2 = @db[:i2]
+    @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)
+  end
+
+  specify "using #with should be able to update" do
+    @ds.insert(:id=>1)
+    @ds2.insert(:id=>2, :parent_id=>1)
+    @ds2.insert(:id=>3, :parent_id=>2)
+    @ds.with(:t, @ds2).filter(:id => @db[:t].select(:id)).update(:parent_id => @db[:t].filter(:id => :i1__id).select(:parent_id).limit(1))
+    @ds[:id => 1].should == {:id => 1, :parent_id => nil}
+    @ds[:id => 2].should == {:id => 2, :parent_id => 1}
+    @ds[:id => 3].should == {:id => 3, :parent_id => 2}
+    @ds[:id => 4].should == {:id => 4, :parent_id => 1}
+  end
+
+  specify "using #with_recursive should be able to update" do
+    ds = @ds.with_recursive(:t, @ds.filter(:parent_id=>1).or(:id => 1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
+    ds.filter(~{:id => @db[:t].select(:i)}).update(:parent_id => 1)
+    @ds[:id => 1].should == {:id => 1, :parent_id => nil}
+    @ds[:id => 2].should == {:id => 2, :parent_id => 1}
+    @ds[:id => 5].should == {:id => 5, :parent_id => 3}
+  end
+
+  specify "using #with should be able to insert" do
+    @ds2.insert(:id=>7)
+    @ds.with(:t, @ds2).insert(@db[:t])
+    @ds[:id => 7].should == {:id => 7, :parent_id => nil}
+  end
+
+  specify "using #with_recursive should be able to insert" do
+    ds = @ds2.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
+    ds.insert @db[:t]
+    @ds2.all.should == [{:id => 3, :parent_id => 1}, {:id => 4, :parent_id => 1}, {:id => 5, :parent_id => 3}, {:id => 6, :parent_id => 5}]
+  end
+
+  specify "using #with should be able to delete" do
+    @ds2.insert(:id=>6)
+    @ds2.insert(:id=>5)
+    @ds2.insert(:id=>4)
+    @ds.with(:t, @ds2).filter(:id => @db[:t].select(:id)).delete
+    @ds.all.should == [{:id => 1, :parent_id => nil}, {:id => 2, :parent_id => nil}, {:id => 3, :parent_id => 1}]
+  end
+
+  specify "using #with_recursive should be able to delete" do
+    @ds.insert(:id=>7, :parent_id=>2)
+    ds = @ds.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
+    ds.filter(:i1__id => @db[:t].select(:i)).delete
+    @ds.all.should == [{:id => 1, :parent_id => nil}, {:id => 2, :parent_id => nil}, {:id => 7, :parent_id => 2}]
+  end
+
+  specify "using #with should be able to import" do
+    @ds2.insert(:id=>7)
+    @ds.with(:t, @ds2).import [:id, :parent_id], @db[:t].select(:id, :parent_id)
+    @ds[:id => 7].should == {:id => 7, :parent_id => nil}
+  end
+
+  specify "using #with_recursive should be able to import" do
+    ds = @ds2.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
+    ds.import [:id, :parent_id], @db[:t].select(:i, :pi)
+    @ds2.all.should == [{:id => 3, :parent_id => 1}, {:id => 4, :parent_id => 1}, {:id => 5, :parent_id => 3}, {:id => 6, :parent_id => 5}]
+  end
+end
+

data/spec/adapters/mysql_spec.rb

@@ -449,6 +449,12 @@ context "A MySQL database" do
     @db[:items].insert(2**40)
     @db[:items].all.should == [{:id=>2**40}]
   end
+
+  specify "should have set_column_type pass through options" do
+    @db.create_table(:items){integer :id; enum :list, :elements=>%w[one]}
+    @db.alter_table(:items){set_column_type :id, :int, :unsigned=>true, :size=>8; set_column_type :list, :enum, :elements=>%w[two]}
+    @db.sqls.should == ["CREATE TABLE items (id integer, list enum('one'))", "DESCRIBE items", "ALTER TABLE items CHANGE COLUMN id id int(8) UNSIGNED NULL", "ALTER TABLE items CHANGE COLUMN list list enum('two') NULL"]
+  end
   
   specify "should have set_column_default support keep existing options" do
     @db.create_table(:items){Integer :id, :null=>false, :default=>5}
@@ -479,14 +485,6 @@ context "A MySQL database" do
     @db << 'DELETE FROM items'
     @db[:items].first.should == nil
   end
-  
-  specify "should handle multiple select statements at once" do
-    @db.create_table(:items){String :name; Integer :value}
-    @db[:items].delete
-    @db[:items].insert(:name => 'tutu', :value => 1234)
-    @db["SELECT * FROM items; SELECT * FROM items"].all.should == \
-      [{:name => 'tutu', :value => 1234}, {:name => 'tutu', :value => 1234}]
-  end
 end  
 
 # Socket tests should only be run if the MySQL server is on localhost
@@ -906,4 +904,44 @@ if MYSQL_DB.class.adapter_scheme == :mysql
       MYSQL_DB["SELECT CAST('25:00:00' AS time)"].single_value.should == '25:00:00'
     end
   end
+  
+  context "MySQL multiple result sets" do
+    before do
+      MYSQL_DB.create_table!(:a){Integer :a}
+      MYSQL_DB.create_table!(:b){Integer :b}
+      @ds = MYSQL_DB['SELECT * FROM a; SELECT * FROM b']
+      MYSQL_DB[:a].insert(10)
+      MYSQL_DB[:a].insert(15)
+      MYSQL_DB[:b].insert(20)
+      MYSQL_DB[:b].insert(25)
+    end
+    after do
+      MYSQL_DB.drop_table(:a, :b)
+    end
+    
+    specify "should combine all results by default" do
+      @ds.all.should == [{:a=>10}, {:a=>15}, {:b=>20}, {:b=>25}]
+    end
+    
+    specify "should split results returned into arrays if split_multiple_result_sets is used" do
+      @ds.split_multiple_result_sets.all.should == [[{:a=>10}, {:a=>15}], [{:b=>20}, {:b=>25}]]
+    end
+    
+    specify "should have regular row_procs work when splitting multiple result sets" do
+      @ds.row_proc = proc{|x| x[x.keys.first] *= 2; x}
+      @ds.split_multiple_result_sets.all.should == [[{:a=>20}, {:a=>30}], [{:b=>40}, {:b=>50}]]
+    end
+    
+    specify "should use the columns from the first result set when splitting result sets" do
+      @ds.split_multiple_result_sets.columns.should == [:a]
+    end
+    
+    specify "should not allow graphing a dataset that splits multiple statements" do
+      proc{@ds.split_multiple_result_sets.graph(:b, :b=>:a)}.should raise_error(Sequel::Error)
+    end
+    
+    specify "should not allow splitting a graphed dataset" do
+      proc{MYSQL_DB[:a].graph(:b, :b=>:a).split_multiple_result_sets}.should raise_error(Sequel::Error)
+    end
+  end
 end