sequel 3.21.0 → 3.28.0

data/spec/integration/schema_test.rb

@@ -6,18 +6,21 @@ describe "Database schema parser" do
     @iom = INTEGRATION_DB.identifier_output_method
     @iim = INTEGRATION_DB.identifier_input_method
     @defsch = INTEGRATION_DB.default_schema
+    @qi = INTEGRATION_DB.quote_identifiers?
     clear_sqls
   end
   after do
     INTEGRATION_DB.identifier_output_method = @iom
     INTEGRATION_DB.identifier_input_method = @iim
     INTEGRATION_DB.default_schema = @defsch
+    INTEGRATION_DB.quote_identifiers = @qi
     INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
   end
 
   specify "should handle a database with a identifier_output_method" do
     INTEGRATION_DB.identifier_output_method = :reverse
     INTEGRATION_DB.identifier_input_method = :reverse
+    INTEGRATION_DB.quote_identifiers = true
     INTEGRATION_DB.default_schema = nil if INTEGRATION_DB.default_schema
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items, :reload=>true).should be_a_kind_of(Array)
@@ -85,7 +88,7 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == 'blah'
   end
 
-  specify "should parse types from the schema properly" do
+  cspecify "should parse types from the schema properly", [:jdbc, :db2] do
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
     INTEGRATION_DB.create_table!(:items){Fixnum :number}
@@ -174,6 +177,24 @@ describe "Database schema modifiers" do
     @db.create_table!(:items, :temp=>true){Integer :number}
   end
   
+  specify "should have create_table? only create the table if it doesn't already exist" do
+    @db.create_table!(:items){String :a}
+    @db.create_table?(:items){String :b}
+    @db[:items].columns.should == [:a]
+    @db.drop_table(:items) rescue nil
+    @db.create_table?(:items){String :b}
+    @db[:items].columns.should == [:b]
+  end
+
+  specify "should have create_table? work correctly with indexes" do
+    @db.create_table!(:items){String :a, :index=>true}
+    @db.create_table?(:items){String :b, :index=>true}
+    @db[:items].columns.should == [:a]
+    @db.drop_table(:items) rescue nil
+    @db.create_table?(:items){String :b, :index=>true}
+    @db[:items].columns.should == [:b]
+  end
+
   specify "should rename tables correctly" do
     @db.drop_table(:items) rescue nil
     @db.create_table!(:items2){Integer :number}
@@ -215,7 +236,7 @@ describe "Database schema modifiers" do
   specify "should add columns to tables correctly" do
     @db.create_table!(:items){Integer :number}
     @ds.insert(:number=>10)
-    @db.alter_table(:items){add_column :name, :text}
+    @db.alter_table(:items){add_column :name, String}
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name]
     @ds.columns!.should == [:number, :name]
     @ds.all.should == [{:number=>10, :name=>nil}]
@@ -228,6 +249,15 @@ describe "Database schema modifiers" do
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :id]
     @ds.columns!.should == [:number, :id]
     @ds.map(:number).should == [10]
+    proc{@ds.insert(:id=>@ds.map(:id).first)}.should raise_error
+  end
+
+  cspecify "should drop primary key constraints from tables correctly", :sqlite do
+    @db.create_table!(:items){Integer :number; primary_key [:number], :name=>:items_pk}
+    @ds.insert(:number=>10)
+    @db.alter_table(:items){drop_constraint :items_pk, :type=>:primary_key}
+    @ds.map(:number).should == [10]
+    proc{@ds.insert(10)}.should_not raise_error
   end
 
   specify "should add foreign key columns to tables correctly" do
@@ -269,7 +299,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert(:n=>nil)}.should raise_error(Sequel::DatabaseError)
   end
 
-  specify "should set column NULL/NOT NULL correctly" do
+  cspecify "should set column NULL/NOT NULL correctly", [:jdbc, :db2] do
     @db.create_table!(:items, :engine=>:InnoDB){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_allow_null :id, false}
@@ -291,7 +321,7 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:id=>10}, {:id=>20}]
   end
 
-  specify "should set column types correctly" do
+  cspecify "should set column types correctly", [:jdbc, :db2] do
     @db.create_table!(:items){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_type :id, String}
@@ -301,17 +331,50 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:id=>"10"}, {:id=>"20"}]
   end
 
-  cspecify "should add unique constraints and foreign key table constraints correctly", :sqlite do
-    @db.create_table!(:items){Integer :id; Integer :item_id}
+  cspecify "should add unnamed unique constraints and foreign key table constraints correctly", :sqlite do
+    @db.create_table!(:items, :engine=>:InnoDB){Integer :id; Integer :item_id}
     @db.alter_table(:items) do
       add_unique_constraint [:item_id, :id]
       add_foreign_key [:id, :item_id], :items, :key=>[:item_id, :id]
     end
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
     @ds.columns!.should == [:id, :item_id]
+    proc{@ds.insert(1, 1)}.should_not raise_error
+    proc{@ds.insert(1, 1)}.should raise_error
+    proc{@ds.insert(1, 2)}.should raise_error
+  end
+
+  cspecify "should add named unique constraints and foreign key table constraints correctly", :sqlite do
+    @db.create_table!(:items, :engine=>:InnoDB){Integer :id, :null=>false; Integer :item_id, :null=>false}
+    @db.alter_table(:items) do
+      add_unique_constraint [:item_id, :id], :name=>:unique_iii
+      add_foreign_key [:id, :item_id], :items, :key=>[:item_id, :id], :name=>:fk_iii
+    end
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
+    proc{@ds.insert(1, 1)}.should_not raise_error
+    proc{@ds.insert(1, 1)}.should raise_error
+    proc{@ds.insert(1, 2)}.should raise_error
+  end
+
+  cspecify "should drop unique constraints and foreign key table constraints correctly", :sqlite do
+    @db.create_table!(:items) do
+      Integer :id
+      Integer :item_id
+      unique [:item_id, :id], :name=>:items_uk
+      foreign_key [:id, :item_id], :items, :key=>[:item_id, :id], :name=>:items_fk
+    end
+    @db.alter_table(:items) do
+      drop_constraint(:items_fk, :type=>:foreign_key)
+      drop_constraint(:items_uk, :type=>:unique)
+    end
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
+    proc{@ds.insert(1, 2)}.should_not raise_error
+    proc{@ds.insert(1, 2)}.should_not raise_error
   end
 
-  cspecify "should remove columns from tables correctly", :h2, :mssql do
+  cspecify "should remove columns from tables correctly", :h2, :mssql, [:jdbc, :db2] do
     @db.create_table!(:items) do
       primary_key :id
       String :name
@@ -332,7 +395,7 @@ describe "Database schema modifiers" do
     @ds.columns!.should == [:id]
   end
 
-  specify "should remove multiple columns in a single alter_table block" do
+  cspecify "should remove multiple columns in a single alter_table block", [:jdbc, :db2] do
     @db.create_table!(:items) do
       primary_key :id
       String :name
@@ -362,25 +425,74 @@ describe "Database#tables" do
         "xxxxx#{@@xxxxx += 1}"
       end
     end
-    @iom = INTEGRATION_DB.identifier_output_method
-    @iim = INTEGRATION_DB.identifier_input_method
+    @db = INTEGRATION_DB
+    @db.create_table(:sequel_test_table){Integer :a}
+    @db.create_view :sequel_test_view, @db[:sequel_test_table]
+    @iom = @db.identifier_output_method
+    @iim = @db.identifier_input_method
     clear_sqls
   end
   after do
-    INTEGRATION_DB.identifier_output_method = @iom
-    INTEGRATION_DB.identifier_input_method = @iim
+    @db.identifier_output_method = @iom
+    @db.identifier_input_method = @iim
+    @db.drop_view :sequel_test_view
+    @db.drop_table :sequel_test_table
+  end
+
+  specify "should return an array of symbols" do
+    ts = @db.tables
+    ts.should be_a_kind_of(Array)
+    ts.each{|t| t.should be_a_kind_of(Symbol)}
+    ts.should include(:sequel_test_table)
+    ts.should_not include(:sequel_test_view)
+  end
+
+  specify "should respect the database's identifier_output_method" do
+    @db.identifier_output_method = :xxxxx
+    @db.identifier_input_method = :xxxxx
+    @db.tables.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
+  end
+end
+end
+
+begin
+  INTEGRATION_DB.views
+rescue Sequel::NotImplemented
+rescue
+describe "Database#views" do
+  before do
+    class ::String
+      @@xxxxx = 0
+      def xxxxx
+        "xxxxx#{@@xxxxx += 1}"
+      end
+    end
+    @db = INTEGRATION_DB
+    @db.create_table(:sequel_test_table){Integer :a}
+    @db.create_view :sequel_test_view, @db[:sequel_test_table]
+    @iom = @db.identifier_output_method
+    @iim = @db.identifier_input_method
+    clear_sqls
+  end
+  after do
+    @db.identifier_output_method = @iom
+    @db.identifier_input_method = @iim
+    @db.drop_view :sequel_test_view
+    @db.drop_table :sequel_test_table
   end
 
   specify "should return an array of symbols" do
-    ts = INTEGRATION_DB.tables
+    ts = @db.views
     ts.should be_a_kind_of(Array)
     ts.each{|t| t.should be_a_kind_of(Symbol)}
+    ts.should_not include(:sequel_test_table)
+    ts.should include(:sequel_test_view)
   end
 
   specify "should respect the database's identifier_output_method" do
-    INTEGRATION_DB.identifier_output_method = :xxxxx
-    INTEGRATION_DB.identifier_input_method = :xxxxx
-    INTEGRATION_DB.tables.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
+    @db.identifier_output_method = :xxxxx
+    @db.identifier_input_method = :xxxxx
+    @db.views.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
   end
 end
 end

data/spec/integration/spec_helper.rb

@@ -9,6 +9,11 @@ begin
 rescue LoadError
 end
 
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
 Sequel::Model.use_transactions = false
 
 $sqls = []
@@ -44,6 +49,7 @@ end
   end
 
   def self.cspecify(message, *checked, &block)
+    return specify(message, &block) if ENV['SEQUEL_NO_PENDING']
     pending = false
     checked.each do |c|
       case c
@@ -84,3 +90,12 @@ if defined?(INTEGRATION_DB) || defined?(INTEGRATION_URL) || ENV['SEQUEL_INTEGRAT
 else
   INTEGRATION_DB = Sequel.sqlite('', :quote_identifiers=>false)
 end
+
+if INTEGRATION_DB.adapter_scheme == :ibmdb
+  def INTEGRATION_DB.drop_table(*tables)
+    super
+  rescue Sequel::DatabaseError
+    disconnect
+    super
+  end
+end

data/spec/integration/transaction_test.rb

@@ -134,4 +134,44 @@ describe "Database transactions" do
       @d.count.should == i + 1
     end
   end
+
+if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' && ![[:do, :sqlite], [:tinytds, :mssql]].include?([INTEGRATION_DB.adapter_scheme, INTEGRATION_DB.database_type]))) and RUBY_VERSION < '1.9'
+  specify "should handle Thread#kill for 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 Thread#kill for 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'
@@ -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], [:mysql2], [:tinytds] 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] 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

@@ -184,6 +184,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 +193,93 @@ 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