sequel 4.49.0 → 5.0.0

data/spec/integration/eager_loader_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Eagerly loading a tree structure" do
   before(:all) do

data/spec/integration/migrator_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 Sequel.extension :migration
 describe Sequel::Migrator do

data/spec/integration/model_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Sequel::Model basic support" do 
   before do
@@ -49,20 +49,9 @@ describe "Sequel::Model basic support" do
     Item.all.must_equal [Item.load(:id=>1, :name=>'J')]
   end
 
-  deprecated "should not raise an error if the implied database table doesn't exist" do
-    class ::Item::Thing < Sequel::Model(@db)
-      set_dataset :items
-    end
-    Item.create(:name=>'J')
-    Item::Thing.first.must_equal Item::Thing.load(:id=>1, :name=>'J')
-  end
-
-  it "should raise an error if the implied database table doesn't exist if require_valid_table is true" do
+  it "should raise an error if the implied database table doesn't exist" do
     proc do
-      c = Sequel::Model(@db)
-      c.require_valid_table = true
-      class ::Item::Thing < c
-        set_dataset :items
+      class ::Item::Thing < Sequel::Model
       end
     end.must_raise Sequel::Error
   end
@@ -108,59 +97,6 @@ describe "Sequel::Model basic support" do
     i.save.must_be_nil
   end
 
-  deprecated "#should respect after_commit, after_rollback, after_destroy_commit, and after_destroy_rollback hooks" do
-    i = Item.create(:name=>'J')
-    i.use_transactions = true
-    def i.hooks
-      @hooks
-    end
-    def i.rb=(x)
-      @hooks = []
-      @rb = x
-    end
-    def i.after_save
-      @hooks << :as
-      raise Sequel::Rollback if @rb
-    end
-    def i.after_destroy
-      @hooks << :ad
-      raise Sequel::Rollback if @rb
-    end
-    def i.after_commit
-      @hooks << :ac
-    end
-    def i.after_rollback
-      @hooks << :ar
-    end
-    def i.after_destroy_commit
-      @hooks << :adc
-    end
-    def i.after_destroy_rollback
-      @hooks << :adr
-    end
-    i.name = 'K'
-    i.rb = true
-    i.save.must_be_nil
-    i.reload.name.must_equal 'J'
-    i.hooks.must_equal [:as, :ar]
-
-    i.rb = true
-    i.destroy.must_be_nil
-    i.exists?.must_equal true
-    i.hooks.must_equal [:ad, :adr]
-
-    i.name = 'K'
-    i.rb = false
-    i.save.wont_equal nil
-    i.reload.name.must_equal 'K'
-    i.hooks.must_equal [:as, :ac]
-
-    i.rb = false
-    i.destroy.wont_equal nil
-    i.exists?.must_equal false
-    i.hooks.must_equal [:ad, :adc]
-  end
-
   it "#exists? should return whether the item is still in the database" do
     i = Item.create(:name=>'J')
     i.exists?.must_equal true
@@ -239,27 +175,13 @@ describe "Sequel::Model basic support" do
 end
 
 describe "Sequel::Model with no existing table" do 
-  deprecated "should not raise an error when setting the dataset" do
-    db = DB
-    db.drop_table?(:items)
-    c = Class.new(Sequel::Model)
-    c.set_dataset(db[:items])
-    db.transaction do
-      c = Class.new(Sequel::Model(db[:items]))
-      db.get(Sequel.cast(1, Integer)).must_equal 1
-    end
-  end
-
-  it "should not raise an error when setting the dataset when require_valid_table is true" do
+  it "should not raise an error when setting the dataset" do
     db = DB
     db.drop_table?(:items)
-    c1 = Sequel::Model(db);
     c = Class.new(Sequel::Model)
-    c.require_valid_table = true
     proc{c.set_dataset(db[:items])}.must_raise Sequel::Error
     db.transaction do
       c = Class.new(Sequel::Model)
-      c.require_valid_table = true
       proc{c.dataset = db[:items]}.must_raise Sequel::Error
       db.get(Sequel.cast(1, Integer)).must_equal 1
     end

data/spec/integration/plugin_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Class Table Inheritance Plugin" do
   before(:all) do
@@ -26,7 +26,7 @@ describe "Class Table Inheritance Plugin" do
   before do
     [:staff, :executives, :managers, :employees].each{|t| @db[t].delete}
     class ::Employee < Sequel::Model(@db)
-      plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}, :alias=>:employees
+      plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}
     end 
     class ::Manager < Employee
       one_to_many :staff_members, :class=>:Staff
@@ -570,7 +570,7 @@ describe "Touch plugin" do
     @album.updated_at.to_i.must_be_close_to Time.now.to_i, 2
   end
   
-  cspecify "should update the timestamp column for many_to_one associated records when the record is updated or destroyed", [:do, :sqlite], [:jdbc, :sqlite], [:swift] do
+  cspecify "should update the timestamp column for many_to_one associated records when the record is updated or destroyed", [:jdbc, :sqlite] do
     Album.many_to_one :artist
     Album.plugin :touch, :associations=>:artist
     @artist.updated_at.must_be_nil
@@ -590,7 +590,7 @@ describe "Touch plugin" do
     end
   end
 
-  cspecify "should update the timestamp column for one_to_many associated records when the record is updated", [:do, :sqlite], [:jdbc, :sqlite], [:swift] do
+  cspecify "should update the timestamp column for one_to_many associated records when the record is updated", [:jdbc, :sqlite] do
     Artist.one_to_many :albums
     Artist.plugin :touch, :associations=>:albums
     @album.updated_at.must_be_nil
@@ -603,7 +603,7 @@ describe "Touch plugin" do
     end
   end
 
-  cspecify "should update the timestamp column for many_to_many associated records when the record is updated", [:do, :sqlite], [:jdbc, :sqlite], [:swift] do
+  cspecify "should update the timestamp column for many_to_many associated records when the record is updated", [:jdbc, :sqlite] do
     Artist.many_to_many :albums
     Artist.plugin :touch, :associations=>:albums
     @artist.add_album(@album)
@@ -1315,25 +1315,9 @@ describe "AssociationPks plugin" do
     Vocalist.order(:first, :last).all.map{|a| a.hit_pks.sort}.must_equal [[@h1, @h2, @h3], [@h2], []]
   end
 
-  deprecated "should handle :delay_pks=>true association option for new instances" do
+  it "should default to delaying association_pks setter method changes until saving" do
     album_class = Class.new(Album)
     album_class.many_to_many :tags, :clone=>:tags, :delay_pks=>true, :join_table=>:albums_tags, :left_key=>:album_id
-    album = album_class.new(:name=>'test album')
-    album.tag_pks.must_equal []
-    album.tag_pks = [@t1, @t2]
-    album.tag_pks.must_equal [@t1, @t2]
-    album.save
-    album_class.with_pk!(album.pk).tag_pks.sort.must_equal [@t1, @t2]
-
-    album.tag_pks = []
-    album.tag_pks.must_equal []
-    album.save
-    album_class.with_pk!(album.pk).tag_pks.sort.must_equal []
-  end
-
-  it "should handle :delay_pks=>:always association option for existing instances" do
-    album_class = Class.new(Album)
-    album_class.many_to_many :tags, :clone=>:tags, :delay_pks=>:always, :join_table=>:albums_tags, :left_key=>:album_id
     album = album_class.with_pk!(@al1)
     album.tag_pks.sort.must_equal [@t1, @t2, @t3]
     album.tag_pks = [@t1, @t2]

data/spec/integration/prepared_statement_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Prepared Statements and Bound Arguments" do
   before do
@@ -332,27 +332,27 @@ describe "Bound Argument Types" do
     @db.drop_table?(:items)
   end
 
-  cspecify "should handle date type", [:do, :sqlite], [:tinytds], [:jdbc, :mssql], [:jdbc, :sqlite], :oracle do 
+  cspecify "should handle date type", [:tinytds], [:jdbc, :mssql], [:jdbc, :sqlite], :oracle do 
     @ds.filter(:d=>:$x).prepare(:first, :ps_date).call(:x=>@vs[:d])[:d].must_equal @vs[:d]
   end
 
-  cspecify "should handle datetime type", [:do], [:mysql2], [:jdbc, :sqlite], [:tinytds], [:oracle] do
+  cspecify "should handle datetime type", [:mysql2], [:jdbc, :sqlite], [:tinytds], [:oracle] do
     Sequel.datetime_class = DateTime
     @ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>@vs[:dt])[:dt].must_equal @vs[:dt]
   end
 
-  cspecify "should handle datetime type with fractional seconds", [:do, :postgres], [:jdbc, :sqlite], [:oracle] do
+  cspecify "should handle datetime type with fractional seconds", [:jdbc, :sqlite], [:oracle] do
     Sequel.datetime_class = DateTime
     fract_time = DateTime.parse('2010-10-12 13:14:15.500000')
     @ds.prepare(:update, :ps_datetime_up, :dt=>:$x).call(:x=>fract_time)
     @ds.literal(@ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>fract_time)[:dt]).must_equal @ds.literal(fract_time)
   end
 
-  cspecify "should handle time type", [:do], [:jdbc, :sqlite], [:swift], [:oracle] do
+  cspecify "should handle time type", [:jdbc, :sqlite] do
     @ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>@vs[:t])[:t].must_equal @vs[:t]
   end
 
-  cspecify "should handle time type with fractional seconds", [:do, :postgres], [:jdbc, :sqlite], [:oracle], [:swift, :postgres] do
+  cspecify "should handle time type with fractional seconds", [:jdbc, :sqlite] do
     fract_time = @vs[:t] + 0.5
     @ds.prepare(:update, :ps_time_up, :t=>:$x).call(:x=>fract_time)
     @ds.literal(@ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>fract_time)[:t]).must_equal @ds.literal(fract_time)
@@ -384,7 +384,7 @@ describe "Bound Argument Types" do
     @ds.get(:file).must_equal zero_blob
   end
 
-  cspecify "should handle float type", [:swift, :sqlite] do
+  it "should handle float type" do
     @ds.filter(:f=>:$x).prepare(:first, :ps_float).call(:x=>@vs[:f])[:f].must_equal @vs[:f]
   end
 
@@ -392,87 +392,7 @@ describe "Bound Argument Types" do
     @ds.filter(:s=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:s])[:s].must_equal @vs[:s]
   end
 
-  cspecify "should handle boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
+  cspecify "should handle boolean type", [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     @ds.filter(:b=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:b])[:b].must_equal @vs[:b]
   end
 end
-
-describe "Dataset#unbind" do
-  before do
-    deprecated do
-      @ds = ds = DB[:items]
-      @ct = proc do |t, v|
-        DB.create_table!(:items) do
-          column :c, t
-        end
-        ds.insert(:c=>v)
-      end
-      @u = proc{|ds1| ds2, bv = ds1.unbind; ds2.call(:first, bv)}
-    end
-  end
-  after do
-    DB.drop_table?(:items)
-  end
-  
-  deprecated "should unbind values assigned to equality and inequality statements" do
-    @ct[Integer, 10]
-    @u[@ds.filter(:c=>10)].must_equal(:c=>10)
-    @u[@ds.exclude(:c=>10)].must_be_nil
-    @u[@ds.filter{c < 10}].must_be_nil
-    @u[@ds.filter{c <= 10}].must_equal(:c=>10)
-    @u[@ds.filter{c > 10}].must_be_nil
-    @u[@ds.filter{c >= 10}].must_equal(:c=>10)
-  end
-
-  cspecify "should handle numerics and strings", [:odbc], [:swift, :sqlite] do
-    deprecated do
-      @ct[Integer, 10]
-      @u[@ds.filter(:c=>10)].must_equal(:c=>10)
-      @ct[Float, 0.0]
-      @u[@ds.filter{c < 1}].must_equal(:c=>0.0)
-      @ct[String, 'foo']
-      @u[@ds.filter(:c=>'foo')].must_equal(:c=>'foo')
-
-      DB.create_table!(:items) do
-        BigDecimal :c, :size=>[15,2]
-      end
-      @ds.insert(:c=>BigDecimal.new('1.1'))
-      @u[@ds.filter{c > 0}].must_equal(:c=>BigDecimal.new('1.1'))
-    end
-  end
-
-  cspecify "should handle dates and times", [:do], [:jdbc, :mssql], [:jdbc, :sqlite], [:swift], [:tinytds], :oracle do
-    deprecated do
-      @ct[Date, Date.today]
-      @u[@ds.filter(:c=>Date.today)].must_equal(:c=>Date.today)
-      t = Time.now
-      @ct[Time, t]
-      @u[@ds.filter{c < t + 1}][:c].to_i.must_equal t.to_i
-    end
-  end
-
-  deprecated "should handle QualifiedIdentifiers" do
-    @ct[Integer, 10]
-    @u[@ds.filter{items[:c] > 1}].must_equal(:c=>10)
-  end
-
-  cspecify "should handle deep nesting", :h2 do
-    deprecated do
-      DB.create_table!(:items) do
-        Integer :a
-        Integer :b
-        Integer :c
-        Integer :d
-      end
-      @ds.insert(:a=>2, :b=>0, :c=>3, :d=>5)
-      @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>4)=>1}, 0) => 1)].must_equal(:a=>2, :b=>0, :c=>3, :d=>5)
-      @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>5)=>1}, 0) => 1)].must_be_nil
-    end
-  end
-
-  deprecated "should handle case where the same variable has the same value in multiple places " do
-    @ct[Integer, 1]
-    @u[@ds.filter{c > 1}.or{c < 1}.invert].must_equal(:c=>1)
-    @u[@ds.filter{c > 1}.or{c < 1}].must_be_nil
-  end
-end    

data/spec/integration/schema_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Database schema parser" do
   after do
@@ -610,7 +610,7 @@ describe "Database schema modifiers" do
     @ds.all.must_equal [{:id2=>10}]
   end
 
-  cspecify "should set column NULL/NOT NULL correctly", [:jdbc, :db2], [:db2] 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}
@@ -632,7 +632,7 @@ describe "Database schema modifiers" do
     @ds.all.must_equal [{:id=>10}, {:id=>20}]
   end
 
-  cspecify "should set column types correctly", [:jdbc, :db2], [:db2], :oracle do
+  cspecify "should set column types correctly", [:jdbc, :db2], :oracle do
     @db.create_table!(:items){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_type :id, String}
@@ -642,7 +642,7 @@ describe "Database schema modifiers" do
     @ds.order(:id).all.must_equal [{:id=>"10"}, {:id=>"20"}]
   end
 
-  cspecify "should set column types without modifying NULL/NOT NULL", [:jdbc, :db2], [:db2], :oracle, :derby do
+  cspecify "should set column types without modifying NULL/NOT NULL", [:jdbc, :db2], :derby do
     @db.create_table!(:items){Integer :id, :null=>false, :default=>2}
     proc{@ds.insert(:id=>nil)}.must_raise(Sequel::NotNullConstraintViolation, Sequel::ConstraintViolation, Sequel::DatabaseError)
     @db.alter_table(:items){set_column_type :id, String}
@@ -655,7 +655,7 @@ describe "Database schema modifiers" do
     @ds.map(:id).must_equal [nil, nil]
   end
 
-  cspecify "should set column types without modifying defaults", [:jdbc, :db2], [:db2], :oracle, :derby do
+  cspecify "should set column types without modifying defaults", [:jdbc, :db2], :oracle, :derby do
     @db.create_table!(:items){Integer :id, :default=>0}
     @ds.insert
     @ds.map(:id).must_equal [0]
@@ -760,7 +760,7 @@ describe "Database schema modifiers" do
     @db.schema(:items, :reload=>true).map{|x| x.first}.must_equal [:id]
   end
 
-  cspecify "should work correctly with many operations in a single alter_table call", [:jdbc, :db2], [:db2] do
+  cspecify "should work correctly with many operations in a single alter_table call", [:jdbc, :db2] do
     @db.create_table!(:items) do
       primary_key :id
       String :name2

data/spec/integration/spec_helper.rb

@@ -1,39 +1,33 @@
-require 'rubygems'
 require 'logger'
-require "#{File.dirname(File.dirname(__FILE__))}/sequel_warning.rb"
+require_relative "../sequel_warning"
 
 if ENV['COVERAGE']
-  require File.join(File.dirname(File.expand_path(__FILE__)), "../sequel_coverage")
+  require_relative "../sequel_coverage"
   SimpleCov.sequel_coverage(:group=>%r{lib/sequel/adapters})
 end
 
-unless Object.const_defined?('Sequel')
-  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel'
-end
+$:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
+require_relative "../../lib/sequel"
+
 begin
-  require File.join(File.dirname(File.dirname(__FILE__)), 'spec_config.rb') unless defined?(DB)
+  require_relative "../spec_config" unless defined?(DB)
 rescue LoadError
 end
 Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_(spec|test)\.rb/}
 
-Sequel.split_symbols = false if ENV['SEQUEL_NO_SPLIT_SYMBOLS']
+Sequel.split_symbols = true if ENV['SEQUEL_SPLIT_SYMBOLS']
 Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
 Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
 Sequel::Model.plugin :prepared_statements if ENV['SEQUEL_MODEL_PREPARED_STATEMENTS']
 Sequel::Model.use_transactions = false
 Sequel::Model.cache_anonymous_models = false
 
-require './spec/guards_helper'
+require_relative '../guards_helper'
 
-IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
+DB = Sequel.connect(ENV['SEQUEL_INTEGRATION_URL']) unless defined?(DB)
 
-unless defined?(DB)
-  # SEQUEL5: Remove :identifier_mangling=>false
-  DB = Sequel.connect(ENV['SEQUEL_INTEGRATION_URL'], :identifier_mangling=>false)
-  DB.extension(:freeze_datasets) if ENV['SEQUEL_FREEZE_DATASETS']
-  DB.extension(:identifier_mangling) if IDENTIFIER_MANGLING
-end
+IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
+DB.extension(:identifier_mangling) if IDENTIFIER_MANGLING
 
 if DB.adapter_scheme == :ibmdb || (DB.adapter_scheme == :ado && DB.database_type == :access)
   def DB.drop_table(*tables)
@@ -44,10 +38,6 @@ if DB.adapter_scheme == :ibmdb || (DB.adapter_scheme == :ado && DB.database_type
   end
 end
 
-if ENV['SEQUEL_NO_AUTO_LITERAL_STRINGS']
-  DB.extension :no_auto_literal_strings
-end
-
 if ENV['SEQUEL_ERROR_SQL']
   DB.extension :error_sql
 end
@@ -68,3 +58,5 @@ if ENV['SEQUEL_FREEZE_DATABASE']
   DB.extension(:pg_array) if DB.database_type == :postgres
   DB.freeze
 end
+
+puts "running #{defined?(SEQUEL_ADAPTER_TEST) ? SEQUEL_ADAPTER_TEST : "integration (database type: #{DB.database_type})"} specs on #{RUBY_ENGINE} #{defined?(JRUBY_VERSION) ? JRUBY_VERSION : RUBY_VERSION} with #{DB.adapter_scheme} adapter"

data/spec/integration/timezone_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Sequel timezone support" do
   def _test_timezone(timezone=Sequel.application_timezone)
@@ -39,7 +39,7 @@ describe "Sequel timezone support" do
     @db.drop_table(:t)
   end
 
-  cspecify "should support using UTC for database storage and local time for the application", [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using UTC for database storage and local time for the application", [:tinytds], [:oracle] do
     Sequel.database_timezone = :utc
     Sequel.application_timezone = :local
     _test_timezone
@@ -48,7 +48,7 @@ describe "Sequel timezone support" do
     _test_timezone
   end
 
-  cspecify "should support using local time for database storage and UTC for the application", [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using local time for database storage and UTC for the application", [:tinytds], [:oracle] do
     Sequel.database_timezone = :local
     Sequel.application_timezone = :utc
     _test_timezone
@@ -57,7 +57,7 @@ describe "Sequel timezone support" do
     _test_timezone
   end
 
-  cspecify "should support using UTC for both database storage and for application", [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using UTC for both database storage and for application", [:oracle] do
     Sequel.default_timezone = :utc
     _test_timezone
     Sequel.database_timezone = :local
@@ -65,7 +65,7 @@ describe "Sequel timezone support" do
     _test_timezone
   end
 
-  cspecify "should support using local time for both database storage and for application", [:do, :postgres], [:oracle] do
+  cspecify "should support using local time for both database storage and for application", [:oracle] do
     Sequel.default_timezone = :local
     _test_timezone
     Sequel.database_timezone = :utc