sequel 3.21.0 → 3.32.0

data/spec/integration/transaction_test.rb

@@ -1,14 +1,16 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Database transactions" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.drop_table(:items) if @db.table_exists?(:items)
     @db.create_table(:items, :engine=>'InnoDB'){String :name; Integer :value}
     @d = @db[:items]
-    clear_sqls
   end
-  after do
+  before do
+    @d.delete
+  end
+  after(:all) do
     @db.drop_table(:items) if @db.table_exists?(:items)
   end
 
@@ -21,6 +23,13 @@ describe "Database transactions" do
     @db.transaction{|conn| conn.should_not == nil}
   end
 
+  specify "should have #in_transaction? work correctly" do
+    @db.in_transaction?.should be_false
+    c = nil
+    @db.transaction{c = @db.in_transaction?}
+    c.should be_true
+  end
+
   specify "should correctly rollback transactions" do
     proc do
       @db.transaction do
@@ -29,12 +38,22 @@ describe "Database transactions" do
       end
     end.should raise_error(Interrupt)
 
+    @db.transaction do
+      @d << {:name => 'abc', :value => 1}
+      raise Sequel::Rollback
+    end.should be_nil
+
     proc do
-      @db.transaction do
+      @db.transaction(:rollback=>:reraise) do
         @d << {:name => 'abc', :value => 1}
         raise Sequel::Rollback
       end
-    end.should_not raise_error
+    end.should raise_error(Sequel::Rollback)
+
+    @db.transaction(:rollback=>:always) do
+      @d << {:name => 'abc', :value => 1}
+      2
+    end.should be_nil
 
     @d.count.should == 0
   end
@@ -115,6 +134,16 @@ describe "Database transactions" do
   end
 
   if INTEGRATION_DB.supports_prepared_transactions?
+    specify "should allow saving and destroying of model objects" do
+      c = Class.new(Sequel::Model(@d))
+      c.set_primary_key :name
+      c.unrestrict_primary_key
+      c.use_after_commit_rollback = false
+      @db.transaction(:prepare=>'XYZ'){c.create(:name => '1'); c.create(:name => '2').destroy}
+      @db.commit_prepared_transaction('XYZ')
+      @d.select_order_map(:name).should == ['1']
+    end
+
     specify "should commit prepared transactions using commit_prepared_transaction" do
       @db.transaction(:prepare=>'XYZ'){@d << {:name => '1'}}
       @db.commit_prepared_transaction('XYZ')
@@ -126,6 +155,14 @@ describe "Database transactions" do
       @db.rollback_prepared_transaction('XYZ')
       @d.select_order_map(:name).should == []
     end
+
+    if INTEGRATION_DB.supports_savepoints?
+      specify "should support savepoints when using prepared transactions" do
+        @db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@d << {:name => '1'}}}
+        @db.commit_prepared_transaction('XYZ')
+        @d.select_order_map(:name).should == ['1']
+      end
+    end
   end
 
   specify "should support all transaction isolation levels" do
@@ -134,4 +171,144 @@ describe "Database transactions" do
       @d.count.should == i + 1
     end
   end
+
+  specify "should support after_commit outside transactions" do
+    c = nil
+    @db.after_commit{c = 1}
+    c.should == 1
+  end
+
+  specify "should support after_rollback outside transactions" do
+    c = nil
+    @db.after_rollback{c = 1}
+    c.should be_nil
+  end
+
+  specify "should support after_commit inside transactions" do
+    c = nil
+    @db.transaction{@db.after_commit{c = 1}; c.should be_nil}
+    c.should == 1
+  end
+
+  specify "should support after_rollback inside transactions" do
+    c = nil
+    @db.transaction{@db.after_rollback{c = 1}; c.should be_nil}
+    c.should be_nil
+  end
+
+  specify "should not call after_commit if the transaction rolls back" do
+    c = nil
+    @db.transaction{@db.after_commit{c = 1}; c.should be_nil; raise Sequel::Rollback}
+    c.should be_nil
+  end
+
+  specify "should call after_rollback if the transaction rolls back" do
+    c = nil
+    @db.transaction{@db.after_rollback{c = 1}; c.should be_nil; raise Sequel::Rollback}
+    c.should == 1
+  end
+
+  specify "should support multiple after_commit blocks inside transactions" do
+    c = []
+    @db.transaction{@db.after_commit{c << 1}; @db.after_commit{c << 2}; c.should == []}
+    c.should == [1, 2]
+  end
+
+  specify "should support multiple after_rollback blocks inside transactions" do
+    c = []
+    @db.transaction{@db.after_rollback{c << 1}; @db.after_rollback{c << 2}; c.should == []; raise Sequel::Rollback}
+    c.should == [1, 2]
+  end
+
+  specify "should support after_commit inside nested transactions" do
+    c = nil
+    @db.transaction{@db.transaction{@db.after_commit{c = 1}}; c.should be_nil}
+    c.should == 1
+  end
+
+  specify "should support after_rollback inside nested transactions" do
+    c = nil
+    @db.transaction{@db.transaction{@db.after_rollback{c = 1}}; c.should be_nil; raise Sequel::Rollback}
+    c.should == 1
+  end
+
+  if INTEGRATION_DB.supports_savepoints?
+    specify "should support after_commit inside savepoints" do
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit{c = 1}}; c.should be_nil}
+      c.should == 1
+    end
+
+    specify "should support after_rollback inside savepoints" do
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_rollback{c = 1}}; c.should be_nil; raise Sequel::Rollback}
+      c.should == 1
+    end
+  end
+
+  if INTEGRATION_DB.supports_prepared_transactions?
+    specify "should raise an error if you attempt to use after_commit or after_rollback inside a prepared transaction" do
+      proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{}}}.should raise_error(Sequel::Error)
+      proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{}}}.should raise_error(Sequel::Error)
+    end
+
+    if INTEGRATION_DB.supports_savepoints?
+      specify "should raise an error if you attempt to use after_commit or after rollback inside a savepoint in a prepared transaction" do
+        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{}}}}.should raise_error(Sequel::Error)
+        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{}}}}.should raise_error(Sequel::Error)
+      end
+    end
+  end
+end
+
+if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' && !Sequel.guarded?([:do, :sqlite], [:tinytds, :mssql]))) and RUBY_VERSION < '1.9'
+  describe "Database transactions and Thread#kill" do
+    before do
+      @db = INTEGRATION_DB
+      @db.drop_table(:items) if @db.table_exists?(:items)
+      @db.create_table(:items, :engine=>'InnoDB'){String :name; Integer :value}
+      @d = @db[:items]
+    end
+    after do
+      @db.drop_table(:items) if @db.table_exists?(:items)
+    end
+
+    specify "should handle transactions inside threads" do
+      q = Queue.new
+      q1 = Queue.new
+      t = Thread.new do
+        @db.transaction do
+          @d << {:name => 'abc', :value => 1}
+          q1.push nil
+          q.pop
+          @d << {:name => 'def', :value => 2}
+        end
+      end
+      q1.pop
+      t.kill
+      @d.count.should == 0
+    end
+
+    if INTEGRATION_DB.supports_savepoints?
+      specify "should handle transactions with savepoints inside threads" do
+        q = Queue.new
+        q1 = Queue.new
+        t = Thread.new do
+          @db.transaction do
+            @d << {:name => 'abc', :value => 1}
+            @db.transaction(:savepoint=>true) do
+              @d << {:name => 'def', :value => 2}
+              q1.push nil
+              q.pop
+              @d << {:name => 'ghi', :value => 3}
+            end
+            @d << {:name => 'jkl', :value => 4}
+          end
+        end
+        q1.pop
+        t.kill
+        @d.count.should == 0
+      end
+    end
+  end
 end

data/spec/integration/type_test.rb

@@ -6,7 +6,7 @@ describe "Supported types" do
     INTEGRATION_DB[:items]
   end
 
-  cspecify "should support casting correctly", [:sqlite, :sqlite] do
+  specify "should support casting correctly" do
     ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => 1)
     ds.select(:number.cast_string.as(:n)).map(:n).should == %w'1'
@@ -60,7 +60,7 @@ describe "Supported types" do
     ds.all.should == [{:name=>'Test User'}]
   end
   
-  cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], :mssql do
+  cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], :mssql, :oracle do
     ds = create_items_table_with_column(:dat, Date)
     d = Date.today
     ds.insert(:dat => d)
@@ -68,6 +68,20 @@ describe "Supported types" do
     ds.first[:dat].to_s.should == d.to_s
   end
   
+  cspecify "should support generic time type", [:do], [:swift], [:odbc], [:jdbc, :mssql], [:jdbc, :postgres], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle do
+    ds = create_items_table_with_column(:tim, Time, :only_time=>true)
+    t = Sequel::SQLTime.now
+    ds.insert(:tim => t)
+    v = ds.first[:tim]
+    ds.literal(v).should == ds.literal(t)
+    v.should be_a_kind_of(Sequel::SQLTime)
+    ds.delete
+    ds.insert(:tim => v)
+    v2 = ds.first[:tim]
+    ds.literal(v2).should == ds.literal(t)
+    v2.should be_a_kind_of(Sequel::SQLTime)
+  end
+  
   cspecify "should support generic datetime type", [:do, :sqlite], [:jdbc, :sqlite] do
     ds = create_items_table_with_column(:tim, DateTime)
     t = DateTime.now
@@ -86,7 +100,7 @@ describe "Supported types" do
     ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
   end
   
-  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:odbc, :mssql] do
+  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], [:odbc, :mssql], :oracle do
     ds = create_items_table_with_column(:number, TrueClass)
     ds.insert(:number => true)
     ds.all.should == [{:number=>true}]

data/spec/model/association_reflection_spec.rb

@@ -2,15 +2,19 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model::Associations::AssociationReflection, "#associated_class" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
     class ::ParParent < Sequel::Model; end
   end
+  after do
+    Object.send(:remove_const, :ParParent)
+  end
 
   it "should use the :class value if present" do
     @c.many_to_one :c, :class=>ParParent
     @c.association_reflection(:c).keys.should include(:class)
     @c.association_reflection(:c).associated_class.should == ParParent
   end
+
   it "should figure out the class if the :class value is not present" do
     @c.many_to_one :c, :class=>'ParParent'
     @c.association_reflection(:c).keys.should_not include(:class)
@@ -20,15 +24,19 @@ end
 
 describe Sequel::Model::Associations::AssociationReflection, "#primary_key" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
     class ::ParParent < Sequel::Model; end
   end
+  after do
+    Object.send(:remove_const, :ParParent)
+  end
 
   it "should use the :primary_key value if present" do
     @c.many_to_one :c, :class=>ParParent, :primary_key=>:blah__blah
     @c.association_reflection(:c).keys.should include(:primary_key)
     @c.association_reflection(:c).primary_key.should == :blah__blah
   end
+
   it "should use the associated table's primary key if :primary_key is not present" do
     @c.many_to_one :c, :class=>'ParParent'
     @c.association_reflection(:c).keys.should_not include(:primary_key)
@@ -49,8 +57,8 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
   end
 
   it "should use the :reciprocal value if present" do
-    @c = Class.new(Sequel::Model)
-    @d = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
+    @d = Class.new(Sequel::Model(:foo))
     @c.many_to_one :c, :class=>@d, :reciprocal=>:xx
     @c.association_reflection(:c).keys.should include(:reciprocal)
     @c.association_reflection(:c).reciprocal.should == :xx
@@ -111,9 +119,12 @@ end
 
 describe Sequel::Model::Associations::AssociationReflection, "#select" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
     class ::ParParent < Sequel::Model; end
   end
+  after do
+    Object.send(:remove_const, :ParParent)
+  end
 
   it "should use the :select value if present" do
     @c.many_to_one :c, :class=>ParParent, :select=>[:par_parents__id]
@@ -143,9 +154,12 @@ end
 
 describe Sequel::Model::Associations::AssociationReflection, "#associated_object_keys" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
     class ::ParParent < Sequel::Model; end
   end
+  after do
+    Object.send(:remove_const, :ParParent)
+  end
 
   it "should use the primary keys for a many_to_one association" do
     @c.many_to_one :c, :class=>ParParent
@@ -173,9 +187,36 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_object
   end
 end
 
+describe Sequel::Model::Associations::AssociationReflection do
+  before do
+    @c = Class.new(Sequel::Model(:foo))
+    @c.meta_def(:name){"C"}
+  end
+
+  it "one_to_many #qualified_primary_key should be a qualified version of the primary key" do
+    @c.one_to_many :cs, :class=>@c
+    @c.dataset.literal(@c.association_reflection(:cs).qualified_primary_key).should == 'foo.id'
+  end
+
+  it "many_to_many #associated_key_column should be the left key" do
+    @c.many_to_many :cs, :class=>@c
+    @c.association_reflection(:cs).associated_key_column.should == :c_id
+  end
+
+  it "many_to_many #qualified_right_key should be a qualified version of the primary key" do
+    @c.many_to_many :cs, :class=>@c, :right_key=>:c2_id
+    @c.dataset.literal(@c.association_reflection(:cs).qualified_right_key).should == 'cs_cs.c2_id'
+  end
+
+  it "many_to_many #qualified_right_primary_key should be a qualified version of the primary key" do
+    @c.many_to_many :cs, :class=>@c
+    @c.dataset.literal(@c.association_reflection(:cs).qualified_right_primary_key).should == 'foo.id'
+  end
+end
+
 describe Sequel::Model::Associations::AssociationReflection, "#remove_before_destroy?" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
   end
 
   it "should be true for many_to_one and many_to_many associations" do
@@ -184,6 +225,7 @@ describe Sequel::Model::Associations::AssociationReflection, "#remove_before_des
     @c.many_to_many :cs, :class=>@c
     @c.association_reflection(:cs).remove_before_destroy?.should be_true
   end
+
   it "should be false for one_to_one and one_to_many associations" do
     @c.one_to_one :c, :class=>@c
     @c.association_reflection(:c).remove_before_destroy?.should be_false
@@ -192,3 +234,155 @@ describe Sequel::Model::Associations::AssociationReflection, "#remove_before_des
   end
 end
 
+describe Sequel::Model::Associations::AssociationReflection, "#eager_limit_strategy" do
+  before do
+    @c = Class.new(Sequel::Model(:a))
+  end
+  after do
+    Sequel::Model.default_eager_limit_strategy = nil
+  end
+
+  it "should be nil by default for *_one associations" do
+    @c.many_to_one :c, :class=>@c
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+    @c.one_to_one :c, :class=>@c
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+  end
+
+  it "should be :ruby by default for *_many associations" do
+    @c.one_to_many :cs, :class=>@c, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    @c.many_to_many :cs, :class=>@c, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+  end
+
+  it "should be nil for many_to_one associations" do
+    @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>true
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+    @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>:distinct_on
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+  end
+
+  it "should be a symbol for other associations if given a symbol" do
+    @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>:distinct_on
+    @c.association_reflection(:c).eager_limit_strategy.should == :distinct_on
+    @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>:window_function, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+  end
+
+  it "should use :distinct_on for one_to_one associations if picking and the association dataset supports ordered distinct on" do
+    @c.dataset.meta_def(:supports_ordered_distinct_on?){true}
+    @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
+    @c.association_reflection(:c).eager_limit_strategy.should == :distinct_on
+  end
+
+  it "should use :window_function for associations if picking and the association dataset supports window functions" do
+    @c.dataset.meta_def(:supports_window_functions?){true}
+    @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
+    @c.association_reflection(:c).eager_limit_strategy.should == :window_function
+    @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    @c.many_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+  end
+
+  it "should use :ruby for *_many associations if picking and the association dataset doesn't window functions" do
+    @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    @c.many_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+  end
+
+  it "should respect Model.default_eager_limit_strategy to *_many associations" do
+    Sequel::Model.default_eager_limit_strategy = :window_function
+    Sequel::Model.default_eager_limit_strategy.should == :window_function
+    c = Class.new(Sequel::Model)
+    c.dataset = :a
+    c.default_eager_limit_strategy.should == :window_function
+    c.one_to_many :cs, :class=>c, :limit=>1
+    c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    c.many_to_many :cs, :class=>c, :limit=>1
+    c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+
+    Sequel::Model.default_eager_limit_strategy = true
+    c = Class.new(Sequel::Model)
+    c.dataset = :a
+    c.one_to_many :cs, :class=>c, :limit=>1
+    c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    c.dataset.meta_def(:supports_window_functions?){true}
+    c.many_to_many :cs, :class=>c, :limit=>1
+    c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+
+    c.default_eager_limit_strategy = :correlated_subquery
+    c.many_to_many :cs, :class=>c, :limit=>1
+    c.association_reflection(:cs).eager_limit_strategy.should == :correlated_subquery
+  end
+
+  it "should ignore Model.default_eager_limit_strategy for one_to_one associations" do
+    @c.default_eager_limit_strategy = :correlated_subquery
+    @c.one_to_one :c, :class=>@c
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+  end
+end
+
+describe Sequel::Model, " association reflection methods" do
+  before do
+    @c1 = Class.new(Sequel::Model(:nodes)) do
+      def self.name; 'Node'; end
+      def self.to_s; 'Node'; end
+    end
+    MODEL_DB.reset
+  end
+  
+  it "#all_association_reflections should include all association reflection hashes" do
+    @c1.all_association_reflections.should == []
+
+    @c1.associate :many_to_one, :parent, :class => @c1
+    @c1.all_association_reflections.collect{|v| v[:name]}.should == [:parent]
+    @c1.all_association_reflections.collect{|v| v[:type]}.should == [:many_to_one]
+    @c1.all_association_reflections.collect{|v| v[:class]}.should == [@c1]
+
+    @c1.associate :one_to_many, :children, :class => @c1
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:name]}.should == [:children, :parent]
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:type]}.should == [:one_to_many, :many_to_one]
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:class]}.should == [@c1, @c1]
+  end
+
+  it "#association_reflection should return nil for nonexistent association" do
+    @c1.association_reflection(:blah).should == nil
+  end
+
+  it "#association_reflection should return association reflection hash if association exists" do
+    @c1.associate :many_to_one, :parent, :class => @c1
+    @c1.association_reflection(:parent).should be_a_kind_of(Sequel::Model::Associations::AssociationReflection)
+    @c1.association_reflection(:parent)[:name].should == :parent
+    @c1.association_reflection(:parent)[:type].should == :many_to_one
+    @c1.association_reflection(:parent)[:class].should == @c1
+
+    @c1.associate :one_to_many, :children, :class => @c1
+    @c1.association_reflection(:children).should be_a_kind_of(Sequel::Model::Associations::AssociationReflection)
+    @c1.association_reflection(:children)[:name].should == :children
+    @c1.association_reflection(:children)[:type].should == :one_to_many
+    @c1.association_reflection(:children)[:class].should == @c1
+  end
+
+  it "#associations should include all association names" do
+    @c1.associations.should == []
+    @c1.associate :many_to_one, :parent, :class => @c1
+    @c1.associations.should == [:parent]
+    @c1.associate :one_to_many, :children, :class => @c1
+    @c1.associations.sort_by{|x|x.to_s}.should == [:children, :parent]
+  end
+
+  it "association reflections should be copied upon subclasing" do
+    @c1.associate :many_to_one, :parent, :class => @c1
+    c = Class.new(@c1)
+    @c1.associations.should == [:parent]
+    c.associations.should == [:parent]
+    c.associate :many_to_one, :parent2, :class => @c1
+    @c1.associations.should == [:parent]
+    c.associations.sort_by{|x| x.to_s}.should == [:parent, :parent2]
+    c.instance_methods.map{|x| x.to_s}.should include('parent')
+  end
+end