sequel 4.49.0 → 5.0.0

data/spec/adapters/spec_helper.rb

@@ -1,56 +1,37 @@
-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.expand_path(__FILE__))), 'spec_config.rb')
+  require_relative "../spec_config"
 rescue LoadError
 end
 
-Sequel.split_symbols = false if ENV['SEQUEL_NO_SPLIT_SYMBOLS']
+Sequel.split_symbols = true if ENV['SEQUEL_SPLIT_SYMBOLS']
 Sequel::Database.extension :duplicate_column_handler if ENV['SEQUEL_DUPLICATE_COLUMN_HANDLER']
 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.cache_anonymous_models = false
 
-class Sequel::Database
-  def log_duration(duration, message)
-    log_info(message)
-  end
-end
-
-require './spec/guards_helper'
-
-class Minitest::HooksSpec
-  def check_sqls
-    yield unless ENV['SEQUEL_NO_CHECK_SQLS']
-  end
-  def self.check_sqls
-    yield unless ENV['SEQUEL_NO_CHECK_SQLS']
-  end
-end
-
-IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
+require_relative '../guards_helper'
 
 unless defined?(DB)
   env_var = "SEQUEL_#{SEQUEL_ADAPTER_TEST.to_s.upcase}_URL"
   env_var = ENV.has_key?(env_var) ? env_var : 'SEQUEL_INTEGRATION_URL'
-  # SEQUEL5: Remove :identifier_mangling=>false
-  DB = Sequel.connect(ENV[env_var], :identifier_mangling=>false)
-  DB.extension(:freeze_datasets) if ENV['SEQUEL_FREEZE_DATASETS']
-  DB.extension(:identifier_mangling) if IDENTIFIER_MANGLING
+  DB = Sequel.connect(ENV[env_var])
 end
 
+IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
+DB.extension(:identifier_mangling) if IDENTIFIER_MANGLING
+
 if dch = ENV['SEQUEL_DUPLICATE_COLUMNS_HANDLER']
   DB.extension :duplicate_columns_handler
   DB.opts[:on_duplicate_columns] = dch.to_sym unless dch.empty?

data/spec/adapters/sqlanywhere_spec.rb

@@ -1,72 +1,14 @@
 SEQUEL_ADAPTER_TEST = :sqlanywhere
 
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-
-if DB.table_exists?(:test)
-  DB.drop_table(:test)
-end
+require_relative 'spec_helper'
 
 describe "convert_smallint_to_bool" do
   before do
     @db = DB
     @ds = @db[:booltest]
-    @db.send(:remove_instance_variable, :@convert_smallint_to_bool) if @db.instance_variable_defined?(:@convert_smallint_to_bool)
   end
   after do
-    deprecated do
-      Sequel::SqlAnywhere.convert_smallint_to_bool = true
-    end
-    @db.send(:remove_instance_variable, :@convert_smallint_to_bool) if @db.instance_variable_defined?(:@convert_smallint_to_bool)
-  end
-  
-  # SEQUEL5: Remove
-  describe "Sequel::SqlAnywhere.convert_smallint_to_bool" do
-    before do
-      @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
-    end
-    after do
-      @db.drop_table(:booltest)
-    end
-
-    deprecated "should consider smallint datatypes as boolean if set, but if not, as larger smallints" do
-      @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
-      @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :boolean
-      @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-
-      Sequel::SqlAnywhere.convert_smallint_to_bool = false
-      @db.send(:remove_instance_variable, :@convert_smallint_to_bool) if @db.instance_variable_defined?(:@convert_smallint_to_bool)
-      @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :integer
-      @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-    end
-
-    it "should return smallints as bools and integers as integers when set" do
-      @ds.delete
-      @ds.insert(:b=>true, :i=>10)
-      @ds.all.must_equal [{:b=>true, :i=>10}]
-      @ds.delete
-      @ds.insert(:b=>false, :i=>0)
-      @ds.all.must_equal [{:b=>false, :i=>0}]
-      @ds.delete
-      @ds.insert(:b=>true, :i=>1)
-      @ds.all.must_equal [{:b=>true, :i=>1}]
-    end
-
-    deprecated "should return all smallints as integers when unset" do
-      Sequel::SqlAnywhere.convert_smallint_to_bool = false
-      @ds.delete
-      @ds.insert(:b=>true, :i=>10)
-      @ds.all.must_equal [{:b=>1, :i=>10}]
-      @ds.delete
-      @ds.insert(:b=>false, :i=>0)
-      @ds.all.must_equal [{:b=>0, :i=>0}]
-      
-      @ds.delete
-      @ds.insert(:b=>1, :i=>10)
-      @ds.all.must_equal [{:b=>1, :i=>10}]
-      @ds.delete
-      @ds.insert(:b=>0, :i=>0)
-      @ds.all.must_equal [{:b=>0, :i=>0}]
-    end
+    @db.convert_smallint_to_bool = true
   end
   
   describe "Database#convert_smallint_to_bool" do
@@ -135,23 +77,6 @@ describe "convert_smallint_to_bool" do
       @ds.all.must_equal [{:b=>true, :i=>1}]
     end
 
-    deprecated "should return all smallints as integers when unset" do
-      @ds.convert_smallint_to_bool = false
-      @ds.delete
-      @ds.insert(:b=>true, :i=>10)
-      @ds.all.must_equal [{:b=>1, :i=>10}]
-      @ds.delete
-      @ds.insert(:b=>false, :i=>0)
-      @ds.all.must_equal [{:b=>0, :i=>0}]
-    
-      @ds.delete
-      @ds.insert(:b=>1, :i=>10)
-      @ds.all.must_equal [{:b=>1, :i=>10}]
-      @ds.delete
-      @ds.insert(:b=>0, :i=>0)
-      @ds.all.must_equal [{:b=>0, :i=>0}]
-    end
-
     it "should support with_convert_smallint_to_bool for returning modified dataset with setting changed" do
       @ds = @ds.with_convert_smallint_to_bool(false)
       @ds.delete

data/spec/adapters/sqlite_spec.rb

@@ -1,59 +1,17 @@
 SEQUEL_ADAPTER_TEST = :sqlite
 
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative 'spec_helper'
 
 describe "An SQLite database" do
   before do
     @db = DB
-    deprecated do
-    @fk = @db.foreign_keys
-    end
   end
   after do
     @db.drop_table?(:fk)
-    deprecated do
-      @db.auto_vacuum = :none
-      @db.run 'VACUUM'
-      @db.foreign_keys = @fk
-      @db.case_sensitive_like = true
-    end
     @db.use_timestamp_timezones = false
     Sequel.datetime_class = Time
   end
 
-  deprecated "should support getting setting pragma values" do
-    @db.pragma_set(:auto_vacuum, '0')
-    @db.run 'VACUUM'
-    @db.pragma_get(:auto_vacuum).to_s.must_equal '0'
-    @db.pragma_set(:auto_vacuum, '1')
-    @db.run 'VACUUM'
-    @db.pragma_get(:auto_vacuum).to_s.must_equal '1'
-    @db.pragma_set(:auto_vacuum, '2')
-    @db.run 'VACUUM'
-    @db.pragma_get(:auto_vacuum).to_s.must_equal '2'
-  end
-  
-  deprecated "should support getting and setting the auto_vacuum pragma" do
-    @db.auto_vacuum = :full
-    @db.run 'VACUUM'
-    @db.auto_vacuum.must_equal :full
-    @db.auto_vacuum = :incremental
-    @db.run 'VACUUM'
-    @db.auto_vacuum.must_equal :incremental
-    
-    proc {@db.auto_vacuum = :invalid}.must_raise(Sequel::Error)
-  end
-  
-  deprecated "should respect case sensitive like false" do
-    @db.case_sensitive_like = false
-    @db.get(Sequel.like('a', 'A')).to_s.must_equal '1'
-  end
-  
-  deprecated "should respect case sensitive like true" do
-    @db.case_sensitive_like = true
-    @db.get(Sequel.like('a', 'A')).to_s.must_equal '0'
-  end
-  
   it "should support casting to Date by using the date function" do
     @db.get(Sequel.cast('2012-10-20 11:12:13', Date)).must_equal '2012-10-20'
   end
@@ -67,28 +25,6 @@ describe "An SQLite database" do
     @db.sqlite_version.must_be_kind_of(Integer)
   end
   
-  deprecated "should support setting and getting the foreign_keys pragma" do
-    (@db.sqlite_version >= 30619 ? [true, false] : [nil]).must_include(@db.foreign_keys)
-    @db.foreign_keys = true
-    @db.foreign_keys = false
-  end
-  
-  deprecated "should enforce foreign key integrity if foreign_keys pragma is set" do
-    @db.foreign_keys = true
-    @db.create_table!(:fk){primary_key :id; foreign_key :parent_id, :fk}
-    @db[:fk].insert(1, nil)
-    @db[:fk].insert(2, 1)
-    @db[:fk].insert(3, 3)
-    proc{@db[:fk].insert(4, 5)}.must_raise(Sequel::ForeignKeyConstraintViolation, Sequel::ConstraintViolation, Sequel::DatabaseError)
-  end if DB.sqlite_version >= 30619
-  
-  deprecated "should not enforce foreign key integrity if foreign_keys pragma is unset" do
-    @db.foreign_keys = false
-    @db.create_table!(:fk){primary_key :id; foreign_key :parent_id, :fk}
-    @db[:fk].insert(1, 2)
-    @db[:fk].all.must_equal [{:id=>1, :parent_id=>2}]
-  end
-  
   it "should support a use_timestamp_timezones setting" do
     @db.use_timestamp_timezones = true
     @db.create_table!(:fk){Time :time}
@@ -108,29 +44,7 @@ describe "An SQLite database" do
     @db.tables.must_include(:fk)
   end
 
-  deprecated "should support getting and setting the synchronous pragma" do
-    @db.synchronous = :off
-    @db.synchronous.must_equal :off
-    @db.synchronous = :normal
-    @db.synchronous.must_equal :normal
-    @db.synchronous = :full
-    @db.synchronous.must_equal :full
-    
-    proc {@db.synchronous = :invalid}.must_raise(Sequel::Error)
-  end
-  
-  deprecated "should support getting and setting the temp_store pragma" do
-    @db.temp_store = :default
-    @db.temp_store.must_equal :default
-    @db.temp_store = :file
-    @db.temp_store.must_equal :file
-    @db.temp_store = :memory
-    @db.temp_store.must_equal :memory
-    
-    proc {@db.temp_store = :invalid}.must_raise(Sequel::Error)
-  end
-  
-  cspecify "should support timestamps and datetimes and respect datetime_class", [:do], [:jdbc], [:swift] do
+  cspecify "should support timestamps and datetimes and respect datetime_class", [:jdbc] do
     @db.create_table!(:fk){timestamp :t; datetime :d}
     @db.use_timestamp_timezones = true
     t1 = Time.at(1)
@@ -312,32 +226,6 @@ describe "An SQLite dataset" do
   end
 end
 
-describe "An SQLite dataset AS clause" do
-  it "should use a string literal for Sequel[:col].as(:alias)" do
-    DB.literal(Sequel[:c].as(:a)).must_equal "`c` AS 'a'"
-  end
-
-  it "should use a string literal for Sequel[:table][:col].as(:alias)" do
-    DB.literal(Sequel[:t][:c].as(:a)).must_equal "`t`.`c` AS 'a'"
-  end
-
-  it "should use a string literal for :column.as(:alias)" do
-    DB.literal(Sequel.as(:c, :a)).must_equal "`c` AS 'a'"
-  end
-
-  it "should use a string literal in the SELECT clause" do
-    DB[:t].select(Sequel[:c].as(:a)).sql.must_equal "SELECT `c` AS 'a' FROM `t`"
-  end
-
-  it "should use a string literal in the FROM clause" do
-    DB[Sequel[:t].as(:a)].sql.must_equal "SELECT * FROM `t` AS 'a'"
-  end
-
-  it "should use a string literal in the JOIN clause" do
-    DB[:t].join_table(:natural, :j, nil, :table_alias=>:a).sql.must_equal "SELECT * FROM `t` NATURAL JOIN `j` AS 'a'"
-  end
-end
-
 describe "SQLite::Dataset#delete" do
   before do
     DB.create_table! :items do
@@ -619,8 +507,6 @@ describe "A SQLite database" do
   end
   
   it "should choose a temporary table name that isn't already used when dropping or renaming columns" do
-    sqls = []
-    @db.loggers << (l=Class.new{%w'info error'.each{|m| define_method(m){|sql| sqls << sql}}}.new)
     @db.tables.each{|t| @db.drop_table(t) if t.to_s =~ /test3/}
     @db.create_table :test3 do
       Integer :h
@@ -636,10 +522,7 @@ describe "A SQLite database" do
     @db[:test3].columns.must_equal [:h, :i]
     @db[:test3_backup0].columns.must_equal [:j]
     @db[:test3_backup1].columns.must_equal [:k]
-    sqls.clear
     @db.drop_column(:test3, :i)
-    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup2/}.must_equal true
-    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup[01]/}.must_equal false
     @db[:test3].columns.must_equal [:h]
     @db[:test3_backup0].columns.must_equal [:j]
     @db[:test3_backup1].columns.must_equal [:k]
@@ -648,15 +531,11 @@ describe "A SQLite database" do
       Integer :l
     end
 
-    sqls.clear
     @db.rename_column(:test3, :h, :i)
-    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup3/}.must_equal true
-    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup[012]/}.must_equal false
     @db[:test3].columns.must_equal [:i]
     @db[:test3_backup0].columns.must_equal [:j]
     @db[:test3_backup1].columns.must_equal [:k]
     @db[:test3_backup2].columns.must_equal [:l]
-    @db.loggers.delete(l)
   end
   
   it "should support add_index" do
@@ -679,34 +558,17 @@ describe "A SQLite database" do
   end
 
   it "should have support for various #transaction modes" do
-    sqls = []
-    @db.loggers << Class.new{%w'info error'.each{|m| define_method(m){|sql| sqls << sql}}}.new
-
-    @db.transaction(:mode => :immediate) do
-      sqls.last.must_equal "BEGIN IMMEDIATE TRANSACTION"
-    end
-    @db.transaction(:mode => :exclusive) do
-      sqls.last.must_equal "BEGIN EXCLUSIVE TRANSACTION"
-    end
-    @db.transaction(:mode => :deferred) do
-      sqls.last.must_equal "BEGIN DEFERRED TRANSACTION"
-    end
-    @db.transaction do
-      sqls.last.must_equal 'BEGIN'
-    end
+    @db.transaction(:mode => :immediate){}
+    @db.transaction(:mode => :exclusive){}
+    @db.transaction(:mode => :deferred){}
+    @db.transaction{}
 
     @db.transaction_mode.must_be_nil
     @db.transaction_mode = :immediate
     @db.transaction_mode.must_equal :immediate
-    @db.transaction do
-      sqls.last.must_equal "BEGIN IMMEDIATE TRANSACTION"
-    end
-    @db.transaction(:mode => :exclusive) do
-      sqls.last.must_equal "BEGIN EXCLUSIVE TRANSACTION"
-    end
-
+    @db.transaction{}
+    @db.transaction(:mode => :exclusive){}
     proc {@db.transaction_mode = :invalid}.must_raise(Sequel::Error)
-
     @db.transaction_mode.must_equal :immediate
     proc {@db.transaction(:mode => :invalid) {}}.must_raise(Sequel::Error)
   end

data/spec/bin_spec.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'rbconfig'
 require 'yaml'
 
@@ -16,15 +15,12 @@ else
   CONN_HASH = {:adapter=>'sqlite', :database=>BIN_SPEC_DB}
 end
 
-unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
-  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel'
-end
+require_relative '../lib/sequel'
 
-DB = Sequel.connect("#{CONN_PREFIX}#{BIN_SPEC_DB}")
-DB2 = Sequel.connect("#{CONN_PREFIX}#{BIN_SPEC_DB2}")
 File.delete(BIN_SPEC_DB) if File.file?(BIN_SPEC_DB)
 File.delete(BIN_SPEC_DB2) if File.file?(BIN_SPEC_DB2)
+DB = Sequel.connect("#{CONN_PREFIX}#{BIN_SPEC_DB}", :test=>false)
+DB2 = Sequel.connect("#{CONN_PREFIX}#{BIN_SPEC_DB2}", :test=>false)
 
 require 'minitest/autorun'
 
@@ -38,16 +34,15 @@ describe "bin/sequel" do
   after do
     DB.disconnect
     DB2.disconnect
-    File.delete(BIN_SPEC_DB) if File.file?(BIN_SPEC_DB)
-    File.delete(BIN_SPEC_DB2) if File.file?(BIN_SPEC_DB2)
-    if File.file?(TMP_FILE)
-      begin
-        File.delete(TMP_FILE)
-      rescue Errno::ENOENT
-        nil
+    [BIN_SPEC_DB, BIN_SPEC_DB2, TMP_FILE, OUTPUT].each do |file|
+      if File.file?(file)
+        begin
+          File.delete(file)
+        rescue Errno::ENOENT
+          nil
+        end
       end
     end
-    File.delete(OUTPUT) if File.file?(OUTPUT)
   end
   
   it "-h should print the help" do
@@ -158,7 +153,7 @@ END
   end
 
   it "-L should load all *.rb files in given directory" do
-    bin(:args=>'-L ./lib/sequel/connection_pool -c "p [Sequel::SingleConnectionPool, Sequel::ThreadedConnectionPool, Sequel::ShardedSingleConnectionPool, Sequel::ShardedThreadedConnectionPool].length"').must_equal "4\n"
+    bin(:args=>'-r ./lib/sequel/extensions/migration -L ./spec/files/integer_migrations -c "p Sequel::Migration.descendants.length"').must_equal "3\n"
   end
 
   it "-m should migrate database up" do