sequel 3.48.0 → 4.0.0

data/spec/adapters/spec_helper.rb

@@ -8,18 +8,14 @@ end
 
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel/no_core_ext'
+  require 'sequel'
 end
 begin
   require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'spec_config.rb')
 rescue LoadError
 end
 
-if ENV['SEQUEL_COLUMNS_INTROSPECTION']
-  Sequel.extension :columns_introspection
-  Sequel::Dataset.introspect_all_columns
-end
-
+Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
 Sequel.cache_anonymous_models = false
 
 class Sequel::Database
@@ -31,10 +27,10 @@ end
 (defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
   def log 
     begin
-      INTEGRATION_DB.loggers << Logger.new(STDOUT)
+      DB.loggers << Logger.new(STDOUT)
       yield
     ensure
-     INTEGRATION_DB.loggers.pop
+     DB.loggers.pop
     end 
   end 
 
@@ -43,12 +39,12 @@ end
     pending = false
     checked.each do |c|
       case c
-      when INTEGRATION_DB.adapter_scheme
+      when DB.adapter_scheme
         pending = c
       when Proc
-        pending = c if c.first.call(INTEGRATION_DB)
+        pending = c if c.first.call(DB)
       when Array
-        pending = c if c.first == INTEGRATION_DB.adapter_scheme && c.last == INTEGRATION_DB.call(INTEGRATION_DB)
+        pending = c if c.first == DB.adapter_scheme && c.last == DB.call(DB)
       end
     end
     if pending
@@ -65,3 +61,9 @@ end
     yield unless ENV['SEQUEL_NO_CHECK_SQLS']
   end
 end
+
+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'
+  DB = Sequel.connect(ENV[env_var])
+end

data/spec/adapters/sqlite_spec.rb

@@ -1,30 +1,21 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+SEQUEL_ADAPTER_TEST = :sqlite
 
-unless defined?(SQLITE_DB)
-  unless defined? SQLITE_URL
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-      SQLITE_URL = 'jdbc:sqlite::memory:'
-    else
-      SQLITE_URL = 'sqlite:/'
-    end
-  end
-  SQLITE_DB = Sequel.connect(ENV['SEQUEL_SQLITE_SPEC_DB']||SQLITE_URL)
-end
-INTEGRATION_DB = SQLITE_DB unless defined?(INTEGRATION_DB)
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "An SQLite database" do
   before do
-    @db = SQLITE_DB
+    @db = DB
     @fk = @db.foreign_keys
   end
   after do
     @db.drop_table?(:fk)
     @db.foreign_keys = @fk
     @db.case_sensitive_like = true
+    @db.use_timestamp_timezones = false
     Sequel.datetime_class = Time
   end
 
-  if SQLITE_DB.auto_vacuum == :none
+  if DB.auto_vacuum == :none
     specify "should support getting pragma values" do
       @db.pragma_get(:auto_vacuum).to_s.should == '0'
     end
@@ -82,7 +73,7 @@ describe "An SQLite database" do
     @db[:fk].insert(2, 1)
     @db[:fk].insert(3, 3)
     proc{@db[:fk].insert(4, 5)}.should raise_error(Sequel::Error)
-  end if SQLITE_DB.sqlite_version >= 30619
+  end if DB.sqlite_version >= 30619
   
   specify "should not enforce foreign key integrity if foreign_keys pragma is unset" do
     @db.foreign_keys = false
@@ -92,6 +83,7 @@ describe "An SQLite database" do
   end
   
   specify "should support a use_timestamp_timezones setting" do
+    @db.use_timestamp_timezones = true
     @db.create_table!(:fk){Time :time}
     @db[:fk].insert(Time.now)
     @db[:fk].get(Sequel.cast(:time, String)).should =~ /[-+]\d\d\d\d\z/
@@ -99,7 +91,6 @@ describe "An SQLite database" do
     @db[:fk].delete
     @db[:fk].insert(Time.now)
     @db[:fk].get(Sequel.cast(:time, String)).should_not =~ /[-+]\d\d\d\d\z/
-    @db.use_timestamp_timezones = true
   end
   
   specify "should provide a list of existing tables" do
@@ -134,6 +125,7 @@ describe "An SQLite database" do
   
   cspecify "should support timestamps and datetimes and respect datetime_class", :do, :jdbc, :amalgalite, :swift do
     @db.create_table!(:fk){timestamp :t; datetime :d}
+    @db.use_timestamp_timezones = true
     t1 = Time.at(1)
     @db[:fk] << {:t => t1, :d => t1}
     @db[:fk].map(:t).should == [t1]
@@ -162,8 +154,8 @@ describe "An SQLite database" do
   end
 
   specify "should handle and return BigDecimal values for numeric columns" do
-    SQLITE_DB.create_table!(:fk){numeric :d}
-    d = SQLITE_DB[:fk]
+    DB.create_table!(:fk){numeric :d}
+    d = DB[:fk]
     d.insert(:d=>BigDecimal.new('80.0'))
     d.insert(:d=>BigDecimal.new('NaN'))
     d.insert(:d=>BigDecimal.new('Infinity'))
@@ -171,13 +163,13 @@ describe "An SQLite database" do
     ds = d.all
     ds.shift.should == {:d=>BigDecimal.new('80.0')}
     ds.map{|x| x[:d].to_s}.should == %w'NaN Infinity -Infinity'
-    SQLITE_DB
+    DB
   end
 end
 
 describe "SQLite temporary views" do
   before do
-    @db = SQLITE_DB
+    @db = DB
     @db.drop_view(:items) rescue nil
     @db.create_table!(:items){Integer :number}
     @db[:items].insert(10)
@@ -197,7 +189,7 @@ end
     
 describe "SQLite type conversion" do
   before do
-    @db = SQLITE_DB
+    @db = DB
     @integer_booleans = @db.integer_booleans
     @db.integer_booleans = true
     @ds = @db[:items]
@@ -280,11 +272,11 @@ describe "SQLite type conversion" do
     @db[:items].update(:a=>'1.1')
     @db[:items].first.should == {:a=>Sequel::SQL::Blob.new(1.1.to_s)}
   end
-end if SQLITE_DB.adapter_scheme == :sqlite
+end if DB.adapter_scheme == :sqlite
 
 describe "An SQLite dataset" do
   before do
-    @d = SQLITE_DB[:items]
+    @d = DB[:items]
   end
   
   specify "should raise errors if given a regexp pattern match" do
@@ -297,38 +289,38 @@ end
 
 describe "An SQLite dataset AS clause" do
   specify "should use a string literal for :col___alias" do
-    SQLITE_DB.literal(:c___a).should == "`c` AS 'a'"
+    DB.literal(:c___a).should == "`c` AS 'a'"
   end
 
   specify "should use a string literal for :table__col___alias" do
-    SQLITE_DB.literal(:t__c___a).should == "`t`.`c` AS 'a'"
+    DB.literal(:t__c___a).should == "`t`.`c` AS 'a'"
   end
 
   specify "should use a string literal for :column.as(:alias)" do
-    SQLITE_DB.literal(Sequel.as(:c, :a)).should == "`c` AS 'a'"
+    DB.literal(Sequel.as(:c, :a)).should == "`c` AS 'a'"
   end
 
   specify "should use a string literal in the SELECT clause" do
-    SQLITE_DB[:t].select(:c___a).sql.should == "SELECT `c` AS 'a' FROM `t`"
+    DB[:t].select(:c___a).sql.should == "SELECT `c` AS 'a' FROM `t`"
   end
 
   specify "should use a string literal in the FROM clause" do
-    SQLITE_DB[:t___a].sql.should == "SELECT * FROM `t` AS 'a'"
+    DB[:t___a].sql.should == "SELECT * FROM `t` AS 'a'"
   end
 
   specify "should use a string literal in the JOIN clause" do
-    SQLITE_DB[:t].join_table(:natural, :j, nil, :table_alias=>:a).sql.should == "SELECT * FROM `t` NATURAL JOIN `j` AS 'a'"
+    DB[:t].join_table(:natural, :j, nil, :table_alias=>:a).sql.should == "SELECT * FROM `t` NATURAL JOIN `j` AS 'a'"
   end
 end
 
 describe "SQLite::Dataset#delete" do
   before do
-    SQLITE_DB.create_table! :items do
+    DB.create_table! :items do
       primary_key :id
       String :name
       Float :value
     end
-    @d = SQLITE_DB[:items]
+    @d = DB[:items]
     @d.delete # remove all records
     @d << {:name => 'abc', :value => 1.23}
     @d << {:name => 'def', :value => 4.56}
@@ -355,12 +347,12 @@ end
 
 describe "SQLite::Dataset#update" do
   before do
-    SQLITE_DB.create_table! :items do
+    DB.create_table! :items do
       primary_key :id
       String :name
       Float :value
     end
-    @d = SQLITE_DB[:items]
+    @d = DB[:items]
     @d.delete # remove all records
     @d << {:name => 'abc', :value => 1.23}
     @d << {:name => 'def', :value => 4.56}
@@ -378,38 +370,38 @@ end
 
 describe "SQLite dataset" do
   before do
-    SQLITE_DB.create_table! :test do
+    DB.create_table! :test do
       primary_key :id
       String :name
       Float :value
     end
-    SQLITE_DB.create_table! :items do
+    DB.create_table! :items do
       primary_key :id
       String :name
       Float :value
     end
-    @d = SQLITE_DB[:items]
+    @d = DB[:items]
     @d << {:name => 'abc', :value => 1.23}
     @d << {:name => 'def', :value => 4.56}
     @d << {:name => 'ghi', :value => 7.89}
   end
   after do
-    SQLITE_DB.drop_table?(:test, :items)
+    DB.drop_table?(:test, :items)
   end
   
   specify "should be able to insert from a subquery" do
-    SQLITE_DB[:test] << @d
-    SQLITE_DB[:test].count.should == 3
-    SQLITE_DB[:test].select(:name, :value).order(:value).to_a.should == \
+    DB[:test] << @d
+    DB[:test].count.should == 3
+    DB[:test].select(:name, :value).order(:value).to_a.should == \
       @d.select(:name, :value).order(:value).to_a
   end
     
   specify "should support #explain" do
-    SQLITE_DB[:test].explain.should be_a_kind_of(String)
+    DB[:test].explain.should be_a_kind_of(String)
   end
   
   specify "should have #explain work when identifier_output_method is modified" do
-    ds = SQLITE_DB[:test]
+    ds = DB[:test]
     ds.identifier_output_method = :upcase
     ds.explain.should be_a_kind_of(String)
   end
@@ -417,7 +409,7 @@ end
 
 describe "A SQLite database" do
   before do
-    @db = SQLITE_DB
+    @db = DB
     @db.create_table! :test2 do
       text :name
       integer :value
@@ -478,7 +470,7 @@ describe "A SQLite database" do
     @db[:test3].select(:id).all.should == [{:id => 1}, {:id => 3}]
   end
 
-  if SQLITE_DB.foreign_keys
+  if DB.foreign_keys
     specify "should keep foreign keys when dropping a column" do
       @db.create_table! :test do
         primary_key :id

data/spec/core/connection_pool_spec.rb

@@ -367,7 +367,8 @@ shared_examples_for "A threaded connection pool" do
     @pool.allocated.should be_empty
   end
 
-  specify "should store connections in a stack by default" do
+  specify "should store connections in a stack if :connection_handling=>:stack" do
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:connection_handling=>:stack))
     c2 = nil
     c = @pool.hold{|cc| Thread.new{@pool.hold{|cc2| c2 = cc2}}.join; cc}
     @pool.size.should == 2

data/spec/core/database_spec.rb

@@ -226,12 +226,6 @@ describe "Sequel.extension" do
   end
 end
 
-describe "Database#connect" do
-  qspecify "should raise Sequel::NotImplemented" do
-    proc {Sequel::Database.new.connect(:default)}.should raise_error(Sequel::NotImplemented)
-  end
-end
-
 describe "Database#log_info" do
   before do
     @o = Object.new
@@ -416,9 +410,9 @@ describe "Database#dataset_class" do
   end
 
   specify "should have getter return the class to use to create datasets" do
-    @db.dataset_class.should == Sequel::Dataset
+    [@db.dataset_class, @db.dataset_class.superclass].should include(Sequel::Dataset)
     @db.dataset_class = @dsc
-    @db.dataset_class.should == @dsc
+    [@db.dataset_class, @db.dataset_class.superclass].should include(@dsc)
   end
 end
   
@@ -504,36 +498,6 @@ describe "Database#valid_connection?" do
   end
 end
 
-describe "Database#execute" do
-  qspecify "should raise Sequel::NotImplemented" do
-    proc {Sequel::Database.new.execute('blah blah')}.should raise_error(Sequel::NotImplemented)
-  end
-end
-
-describe "Database#tables" do
-  qspecify "should raise Sequel::NotImplemented" do
-    proc {Sequel::Database.new.tables}.should raise_error(Sequel::NotImplemented)
-  end
-end
-
-describe "Database#views" do
-  qspecify "should raise Sequel::NotImplemented" do
-    proc {Sequel::Database.new.views}.should raise_error(Sequel::NotImplemented)
-  end
-end
-
-describe "Database#indexes" do
-  qspecify "should raise Sequel::NotImplemented" do
-    proc {Sequel::Database.new.indexes(:table)}.should raise_error(Sequel::NotImplemented)
-  end
-end
-
-describe "Database#foreign_key_list" do
-  qspecify "should raise Sequel::NotImplemented" do
-    proc {Sequel::Database.new.foreign_key_list(:table)}.should raise_error(Sequel::NotImplemented)
-  end
-end
-
 describe "Database#run" do
   before do
     @db = Sequel.mock(:servers=>{:s1=>{}})
@@ -655,13 +619,6 @@ shared_examples_for "Database#transaction" do
                        'BEGIN', 'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE', 'DROP TABLE serializable', 'COMMIT']
   end
   
-  qspecify "should support :disconnect=>:retry option for automatically retrying on disconnect" do
-    a = []
-    @db.transaction(:disconnect=>:retry){a << 1; raise Sequel::DatabaseDisconnectError if a.length < 2}
-    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
-    a.should == [1, 1]
-  end
-  
   specify "should support :retry_on option for automatically retrying transactions" do
     a = []
     @db.transaction(:retry_on=>Sequel::DatabaseDisconnectError){a << 1; raise Sequel::DatabaseDisconnectError if a.length < 2}
@@ -704,12 +661,7 @@ shared_examples_for "Database#transaction" do
     a.should == [1] * 100
   end
   
-  qspecify "should raise an error if using :disconnect=>:retry and :retry_on together" do
-    proc{@db.transaction(:disconnect=>:retry, :retry_on=>Sequel::ConstraintViolation){}}.should raise_error(Sequel::Error)
-    @db.sqls.should == []
-  end
-  
-  specify "should raise an error if attempting to use :disconnect=>:retry or :retry_on inside another transaction" do
+  specify "should raise an error if attempting to use :retry_on inside another transaction" do
     proc{@db.transaction{@db.transaction(:retry_on=>Sequel::ConstraintViolation){}}}.should raise_error(Sequel::Error)
     @db.sqls.should == ['BEGIN', 'ROLLBACK']
   end
@@ -1522,9 +1474,9 @@ describe "Database#get" do
     @db.sqls.should == ['SELECT version(a) AS version LIMIT 1']
   end
 
-  qspecify "should work when an alias cannot be determined" do
+  specify "should work when an alias cannot be determined" do
     @db.get(1).should == 1
-    @db.sqls.should == ['SELECT 1 LIMIT 1']
+    @db.sqls.should == ['SELECT 1 AS v LIMIT 1']
   end
 end
 
@@ -2041,9 +1993,9 @@ describe "Database#typecast_value" do
     end
   end
 
-  qspecify "should typecast hash and array values to String" do
+  specify "should raise errors when typecasting hash and array values to String" do
     [[], {}].each do |i|
-      @db.typecast_value(:string, i).should be_an_instance_of(String)
+      proc{@db.typecast_value(:string, i)}.should raise_error(Sequel::InvalidValue)
     end
   end
 
@@ -2129,6 +2081,54 @@ describe "Database#supports_schema_parsing?" do
   end
 end
 
+describe "Database#supports_foreign_key_parsing?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_foreign_key_parsing?.should == false
+  end
+
+  specify "should be true if the database implements foreign_key_list" do
+    db = Sequel::Database.new
+    def db.foreign_key_list(*) end
+    db.supports_foreign_key_parsing?.should == true
+  end
+end
+
+describe "Database#supports_index_parsing?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_index_parsing?.should == false
+  end
+
+  specify "should be true if the database implements indexes" do
+    db = Sequel::Database.new
+    def db.indexes(*) end
+    db.supports_index_parsing?.should == true
+  end
+end
+
+describe "Database#supports_table_listing?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_table_listing?.should == false
+  end
+
+  specify "should be true if the database implements tables" do
+    db = Sequel::Database.new
+    def db.tables(*) end
+    db.supports_table_listing?.should == true
+  end
+end
+
+describe "Database#supports_view_listing?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_view_listing?.should == false
+  end
+
+  specify "should be true if the database implements views" do
+    db = Sequel::Database.new
+    def db.views(*) end
+    db.supports_view_listing?.should == true
+  end
+end
+
 describe "Database#supports_deferrable_constraints?" do
   specify "should be false by default" do
     Sequel::Database.new.supports_deferrable_constraints?.should == false