sequel 3.21.0 → 3.41.0

data/spec/adapters/spec_helper.rb

@@ -2,14 +2,20 @@ require 'rubygems'
 require 'logger'
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel'
-  Sequel.quote_identifiers = false
+  require 'sequel/no_core_ext'
 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::Model.cache_anonymous_models = false
+
 class Sequel::Database
   def log_duration(duration, message)
     log_info(message)
@@ -26,11 +32,8 @@ end
     end 
   end 
 
-  def self.log_specify(message, &block)
-    specify(message){log{instance_eval(&block)}}
-  end
-
   def self.cspecify(message, *checked, &block)
+    return specify(message, &block) if ENV['SEQUEL_NO_PENDING']
     pending = false
     checked.each do |c|
       case c
@@ -48,4 +51,11 @@ end
       specify(message, &block)
     end
   end
+
+  def check_sqls
+    yield unless ENV['SEQUEL_NO_CHECK_SQLS']
+  end
+  def self.check_sqls
+    yield unless ENV['SEQUEL_NO_CHECK_SQLS']
+  end
 end

data/spec/adapters/sqlite_spec.rb

@@ -1,7 +1,13 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 unless defined?(SQLITE_DB)
-  SQLITE_URL = 'sqlite:/' unless defined? SQLITE_URL
+  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)
@@ -12,7 +18,9 @@ describe "An SQLite database" do
     @fk = @db.foreign_keys
   end
   after do
+    @db.drop_table?(:fk)
     @db.foreign_keys = @fk
+    @db.case_sensitive_like = true
     Sequel.datetime_class = Time
   end
 
@@ -38,6 +46,25 @@ describe "An SQLite database" do
     end
   end
   
+  specify "should respect case sensitive like false" do
+    @db.case_sensitive_like = false
+    @db.get(Sequel.like('a', 'A')).to_s.should == '1'
+  end
+  
+  specify "should respect case sensitive like true" do
+    @db.case_sensitive_like = true
+    @db.get(Sequel.like('a', 'A')).to_s.should == '0'
+  end
+  
+  specify "should support casting to Date by using the date function" do
+    @db.get(Sequel.cast('2012-10-20 11:12:13', Date)).should == '2012-10-20'
+  end
+  
+  specify "should support casting to Time or DateTime by using the datetime function" do
+    @db.get(Sequel.cast('2012-10-20', Time)).should == '2012-10-20 00:00:00'
+    @db.get(Sequel.cast('2012-10-20', DateTime)).should == '2012-10-20 00:00:00'
+  end
+  
   specify "should provide the SQLite version as an integer" do
     @db.sqlite_version.should be_a_kind_of(Integer)
   end
@@ -48,16 +75,14 @@ describe "An SQLite database" do
     @db.foreign_keys = false
   end
   
-  if SQLITE_DB.sqlite_version >= 30619
-    specify "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)}.should raise_error(Sequel::Error)
-    end
-  end
+  specify "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)}.should raise_error(Sequel::Error)
+  end if SQLITE_DB.sqlite_version >= 30619
   
   specify "should not enforce foreign key integrity if foreign_keys pragma is unset" do
     @db.foreign_keys = false
@@ -66,14 +91,23 @@ describe "An SQLite database" do
     @db[:fk].all.should == [{:id=>1, :parent_id=>2}]
   end
   
+  specify "should support a use_timestamp_timezones setting" do
+    @db.create_table!(:fk){Time :time}
+    @db[:fk].insert(Time.now)
+    @db[:fk].get(Sequel.cast(:time, String)).should =~ /[-+]\d\d\d\d\z/
+    @db.use_timestamp_timezones = false
+    @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
-    @db.drop_table(:testing) rescue nil
+    @db.drop_table?(:fk)
     @db.tables.should be_a_kind_of(Array)
-    @db.tables.should_not include(:testing)
-    @db.create_table! :testing do
-      text :name
-    end
-    @db.tables.should include(:testing)
+    @db.tables.should_not include(:fk)
+    @db.create_table!(:fk){String :name}
+    @db.tables.should include(:fk)
   end
 
   specify "should support getting and setting the synchronous pragma" do
@@ -99,23 +133,23 @@ describe "An SQLite database" do
   end
   
   cspecify "should support timestamps and datetimes and respect datetime_class", :do, :jdbc, :amalgalite, :swift do
-    @db.create_table!(:time){timestamp :t; datetime :d}
+    @db.create_table!(:fk){timestamp :t; datetime :d}
     t1 = Time.at(1)
-    @db[:time] << {:t => t1, :d => t1}
-    @db[:time].map(:t).should == [t1]
-    @db[:time].map(:d).should == [t1]
+    @db[:fk] << {:t => t1, :d => t1}
+    @db[:fk].map(:t).should == [t1]
+    @db[:fk].map(:d).should == [t1]
     Sequel.datetime_class = DateTime
     t2 = Sequel.string_to_datetime(t1.iso8601)
-    @db[:time].map(:t).should == [t2]
-    @db[:time].map(:d).should == [t2]
+    @db[:fk].map(:t).should == [t2]
+    @db[:fk].map(:d).should == [t2]
   end
   
   specify "should support sequential primary keys" do
-    @db.create_table!(:with_pk) {primary_key :id; text :name}
-    @db[:with_pk] << {:name => 'abc'}
-    @db[:with_pk] << {:name => 'def'}
-    @db[:with_pk] << {:name => 'ghi'}
-    @db[:with_pk].order(:name).all.should == [
+    @db.create_table!(:fk) {primary_key :id; text :name}
+    @db[:fk] << {:name => 'abc'}
+    @db[:fk] << {:name => 'def'}
+    @db[:fk] << {:name => 'ghi'}
+    @db[:fk].order(:name).all.should == [
       {:id => 1, :name => 'abc'},
       {:id => 2, :name => 'def'},
       {:id => 3, :name => 'ghi'}
@@ -123,68 +157,147 @@ describe "An SQLite database" do
   end
   
   specify "should correctly parse the schema" do
-    @db.create_table!(:time2) {timestamp :t}
-    @db.schema(:time2, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp", :primary_key=>false}]]
+    @db.create_table!(:fk) {timestamp :t}
+    @db.schema(:fk, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp", :primary_key=>false}]]
+  end
+
+  specify "should handle and return BigDecimal values for numeric columns" do
+    SQLITE_DB.create_table!(:fk){numeric :d}
+    d = SQLITE_DB[:fk]
+    d.insert(:d=>BigDecimal.new('80.0'))
+    d.insert(:d=>BigDecimal.new('NaN'))
+    d.insert(:d=>BigDecimal.new('Infinity'))
+    d.insert(:d=>BigDecimal.new('-Infinity'))
+    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
   end
 end
 
-describe "An SQLite dataset" do
+describe "SQLite type conversion" do
   before do
-    @d = SQLITE_DB[:items]
+    @db = SQLITE_DB
+    @integer_booleans = @db.integer_booleans
+    @db.integer_booleans = true
+    @ds = @db[:items]
+    @db.drop_table?(:items)
+  end
+  after do
+    @db.integer_booleans = @integer_booleans
+    Sequel.datetime_class = Time
+    @db.drop_table?(:items)
   end
   
-  specify "should handle string pattern matches correctly" do
-    @d.literal(:x.like('a')).should == "(x LIKE 'a')"
-    @d.literal(~:x.like('a')).should == "NOT (x LIKE 'a')"
-    @d.literal(:x.ilike('a')).should == "(x LIKE 'a')"
-    @d.literal(~:x.ilike('a')).should == "NOT (x LIKE 'a')"
+  specify "should handle integers in boolean columns" do
+    @db.create_table(:items){TrueClass :a}
+    @db[:items].insert(false)
+    @db[:items].select_map(:a).should == [false]
+    @db[:items].select_map(Sequel.expr(:a)+:a).should == [0]
+    @db[:items].update(:a=>true)
+    @db[:items].select_map(:a).should == [true]
+    @db[:items].select_map(Sequel.expr(:a)+:a).should == [2]
+  end
+  
+  specify "should handle integers/floats/strings/decimals in numeric/decimal columns" do
+    @db.create_table(:items){Numeric :a}
+    @db[:items].insert(100)
+    @db[:items].select_map(:a).should == [BigDecimal.new('100')]
+    @db[:items].get(:a).should be_a_kind_of(BigDecimal)
+
+    @db[:items].update(:a=>100.1)
+    @db[:items].select_map(:a).should == [BigDecimal.new('100.1')]
+    @db[:items].get(:a).should be_a_kind_of(BigDecimal)
+
+    @db[:items].update(:a=>'100.1')
+    @db[:items].select_map(:a).should == [BigDecimal.new('100.1')]
+    @db[:items].get(:a).should be_a_kind_of(BigDecimal)
+
+    @db[:items].update(:a=>BigDecimal.new('100.1'))
+    @db[:items].select_map(:a).should == [BigDecimal.new('100.1')]
+    @db[:items].get(:a).should be_a_kind_of(BigDecimal)
+  end
+
+  specify "should handle integer/float date columns as julian date" do
+    @db.create_table(:items){Date :a}
+    i = 2455979
+    @db[:items].insert(i)
+    @db[:items].first.should == {:a=>Date.jd(i)}
+    @db[:items].update(:a=>2455979.1)
+    @db[:items].first.should == {:a=>Date.jd(i)}
+  end
+
+  specify "should handle integer/float time columns as seconds" do
+    @db.create_table(:items){Time :a, :only_time=>true}
+    @db[:items].insert(3661)
+    @db[:items].first.should == {:a=>Sequel::SQLTime.create(1, 1, 1)}
+    @db[:items].update(:a=>3661.000001)
+    @db[:items].first.should == {:a=>Sequel::SQLTime.create(1, 1, 1, 1)}
+  end
+
+  specify "should handle integer datetime columns as unix timestamp" do
+    @db.create_table(:items){DateTime :a}
+    i = 1329860756
+    @db[:items].insert(i)
+    @db[:items].first.should == {:a=>Time.at(i)}
+    Sequel.datetime_class = DateTime
+    @db[:items].first.should == {:a=>DateTime.strptime(i.to_s, '%s')}
   end
 
-  specify "should raise errors if given a regexp pattern match" do
-    proc{@d.literal(:x.like(/a/))}.should raise_error(Sequel::Error)
-    proc{@d.literal(~:x.like(/a/))}.should raise_error(Sequel::Error)
-    proc{@d.literal(:x.like(/a/i))}.should raise_error(Sequel::Error)
-    proc{@d.literal(~:x.like(/a/i))}.should raise_error(Sequel::Error)
+  specify "should handle float datetime columns as julian date" do
+    @db.create_table(:items){DateTime :a}
+    i = 2455979.5
+    @db[:items].insert(i)
+    @db[:items].first.should == {:a=>Time.at(1329825600)}
+    Sequel.datetime_class = DateTime
+    @db[:items].first.should == {:a=>DateTime.jd(2455979.5)}
   end
-end
 
-describe "An SQLite numeric column" do
-  specify "should handle and return BigDecimal values" do
-    SQLITE_DB.create_table!(:d){numeric :d}
-    d = SQLITE_DB[:d]
-    d.insert(:d=>BigDecimal.new('80.0'))
-    d.insert(:d=>BigDecimal.new('NaN'))
-    d.insert(:d=>BigDecimal.new('Infinity'))
-    d.insert(:d=>BigDecimal.new('-Infinity'))
-    ds = d.all
-    ds.shift.should == {:d=>BigDecimal.new('80.0')}
-    ds.map{|x| x[:d].to_s}.should == %w'NaN Infinity -Infinity'
+  specify "should handle integer/float blob columns" do
+    @db.create_table(:items){File :a}
+    @db[:items].insert(1)
+    @db[:items].first.should == {:a=>Sequel::SQL::Blob.new('1')}
+    @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
+
+describe "An SQLite dataset" do
+  before do
+    @d = SQLITE_DB[:items]
+  end
+  
+  specify "should raise errors if given a regexp pattern match" do
+    proc{@d.literal(Sequel.expr(:x).like(/a/))}.should raise_error(Sequel::Error)
+    proc{@d.literal(~Sequel.expr(:x).like(/a/))}.should raise_error(Sequel::Error)
+    proc{@d.literal(Sequel.expr(:x).like(/a/i))}.should raise_error(Sequel::Error)
+    proc{@d.literal(~Sequel.expr(:x).like(/a/i))}.should raise_error(Sequel::Error)
   end
 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'"
+    SQLITE_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'"
+    SQLITE_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(:c.as(:a)).should == "c AS 'a'"
+    SQLITE_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"
+    SQLITE_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'"
+    SQLITE_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, :a).sql.should == "SELECT * FROM t NATURAL JOIN j AS 'a'"
+    SQLITE_DB[:t].join_table(:natural, :j, nil, :a).sql.should == "SELECT * FROM `t` NATURAL JOIN `j` AS 'a'"
   end
 end
 
@@ -204,10 +317,10 @@ describe "SQLite::Dataset#delete" do
   
   specify "should return the number of records affected when filtered" do
     @d.count.should == 3
-    @d.filter(:value.sql_number < 3).delete.should == 1
+    @d.filter{value < 3}.delete.should == 1
     @d.count.should == 2
 
-    @d.filter(:value.sql_number < 3).delete.should == 0
+    @d.filter{value < 3}.delete.should == 0
     @d.count.should == 2
   end
   
@@ -261,7 +374,7 @@ describe "SQLite dataset" do
     @d << {:name => 'ghi', :value => 7.89}
   end
   after do
-    SQLITE_DB.drop_table(:test, :items)
+    SQLITE_DB.drop_table?(:test, :items)
   end
   
   specify "should be able to insert from a subquery" do
@@ -272,13 +385,13 @@ describe "SQLite dataset" do
   end
     
   specify "should support #explain" do
-    SQLITE_DB[:test].explain.should be_a_kind_of(Array)
+    SQLITE_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.identifier_output_method = :upcase
-    ds.explain.should be_a_kind_of(Array)
+    ds.explain.should be_a_kind_of(String)
   end
 end
 
@@ -290,6 +403,9 @@ describe "A SQLite database" do
       integer :value
     end
   end
+  after do
+    @db.drop_table?(:test2)
+  end
 
   specify "should support add_column operations" do
     @db.add_column :test2, :xyz, :text
@@ -313,6 +429,15 @@ describe "A SQLite database" do
     @db[:test2].first.should == {:name => 'mmm'}
   end
 
+  specify "should keep a composite primary key when dropping columns" do
+    @db.create_table!(:test2){Integer :a; Integer :b; Integer :c; primary_key [:a, :b]}
+    @db.drop_column :test2, :c
+    @db[:test2].columns.should == [:a, :b]
+    @db[:test2] << {:a=>1, :b=>2}
+    @db[:test2] << {:a=>2, :b=>3}
+    proc{@db[:test2] << {:a=>2, :b=>3}}.should raise_error(Sequel::Error)
+  end
+
   specify "should keep column attributes when dropping a column" do
     @db.create_table! :test3 do
       primary_key :id
@@ -357,7 +482,7 @@ describe "A SQLite database" do
       @db[:test].filter(:name => 'foo').update(:id=>100)
       @db[:test3][:name => 'abc'][:test_id].should == 100
 
-      @db.drop_table :test, :test3
+      @db.drop_table? :test, :test3
     end
   end
 
@@ -395,7 +520,7 @@ describe "A SQLite database" do
   specify "should handle quoted tables when dropping or renaming columns" do
     @db.quote_identifiers = true
     table_name = "T T"
-    @db.drop_table(table_name) rescue nil
+    @db.drop_table?(table_name)
     @db.create_table! table_name do
       Integer :"s s"
       Integer :"i i"
@@ -407,19 +532,21 @@ describe "A SQLite database" do
     @db.from(table_name).all.should == [{:"s s"=>1}]
     @db.rename_column table_name, :"s s", :"t t"
     @db.from(table_name).all.should == [{:"t t"=>1}]
+    @db.drop_table?(table_name)
   end
   
   specify "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.create_table! :test3 do
+    @db.tables.each{|t| @db.drop_table(t) if t.to_s =~ /test3/}
+    @db.create_table :test3 do
       Integer :h
       Integer :i
     end
-    @db.create_table! :test3_backup0 do
+    @db.create_table :test3_backup0 do
       Integer :j
     end
-    @db.create_table! :test3_backup1 do
+    @db.create_table :test3_backup1 do
       Integer :k
     end
 
@@ -428,25 +555,26 @@ describe "A SQLite database" do
     @db[:test3_backup1].columns.should == [:k]
     sqls.clear
     @db.drop_column(:test3, :i)
-    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup2/}.should == true
-    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup[01]/}.should == false
+    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup2/}.should == true
+    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup[01]/}.should == false
     @db[:test3].columns.should == [:h]
     @db[:test3_backup0].columns.should == [:j]
     @db[:test3_backup1].columns.should == [:k]
 
-    @db.create_table! :test3_backup2 do
+    @db.create_table :test3_backup2 do
       Integer :l
     end
 
     sqls.clear
     @db.rename_column(:test3, :h, :i)
-    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup3/}.should == true
-    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup[012]/}.should == false
+    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup3/}.should == true
+    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup[012]/}.should == false
     @db[:test3].columns.should == [:i]
     @db[:test3_backup0].columns.should == [:j]
     @db[:test3_backup1].columns.should == [:k]
     @db[:test3_backup2].columns.should == [:l]
     @db.loggers.delete(l)
+    @db.drop_table?(:test3, :test3_backup0, :test3_backup1, :test3_backup2)
   end
   
   specify "should support add_index" do
@@ -467,4 +595,37 @@ describe "A SQLite database" do
     @db.drop_column :a, :b
     @db.indexes(:a).should == {:a_a_index=>{:unique=>false, :columns=>[:a]}}
   end
-end  
+
+  specify "should have support for various #transaction modes" do
+    sqls = []
+    @db.loggers << (l=Class.new{%w'info error'.each{|m| define_method(m){|sql| sqls << sql}}}.new)
+
+    @db.transaction(:mode => :immediate) do
+      sqls.last.should == "BEGIN IMMEDIATE TRANSACTION"
+    end
+    @db.transaction(:mode => :exclusive) do
+      sqls.last.should == "BEGIN EXCLUSIVE TRANSACTION"
+    end
+    @db.transaction(:mode => :deferred) do
+      sqls.last.should == "BEGIN DEFERRED TRANSACTION"
+    end
+    @db.transaction do
+      sqls.last.should == Sequel::Database::SQL_BEGIN
+    end
+
+    @db.transaction_mode.should == nil
+    @db.transaction_mode = :immediate
+    @db.transaction_mode.should == :immediate
+    @db.transaction do
+      sqls.last.should == "BEGIN IMMEDIATE TRANSACTION"
+    end
+    @db.transaction(:mode => :exclusive) do
+      sqls.last.should == "BEGIN EXCLUSIVE TRANSACTION"
+    end
+
+    proc {@db.transaction_mode = :invalid}.should raise_error(Sequel::Error)
+
+    @db.transaction_mode.should == :immediate
+    proc {@db.transaction(:mode => :invalid) {}}.should raise_error(Sequel::Error)
+  end
+end