sequel 3.21.0 → 3.36.0

data/spec/adapters/spec_helper.rb

@@ -3,13 +3,19 @@ require 'logger'
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
   require 'sequel'
-  Sequel.quote_identifiers = false
 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

data/spec/adapters/sqlite_spec.rb

@@ -13,6 +13,7 @@ describe "An SQLite database" do
   end
   after do
     @db.foreign_keys = @fk
+    @db.case_sensitive_like = true
     Sequel.datetime_class = Time
   end
 
@@ -38,6 +39,16 @@ 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 provide the SQLite version as an integer" do
     @db.sqlite_version.should be_a_kind_of(Integer)
   end
@@ -66,8 +77,19 @@ 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!(:time){Time :time}
+    @db[:time].insert(Time.now)
+    @db[:time].get(:time.cast_string).should =~ /[-+]\d\d\d\d\z/
+    @db.use_timestamp_timezones = false
+    @db[:time].delete
+    @db[:time].insert(Time.now)
+    @db[:time].get(:time.cast_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?(:testing)
     @db.tables.should be_a_kind_of(Array)
     @db.tables.should_not include(:testing)
     @db.create_table! :testing do
@@ -128,18 +150,98 @@ describe "An SQLite database" do
   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 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(:a+:a).should == [0]
+    @db[:items].update(:a=>true)
+    @db[:items].select_map(:a).should == [true]
+    @db[:items].select_map(:a+:a).should == [2]
   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/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 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
 
+  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(:x.like(/a/))}.should raise_error(Sequel::Error)
     proc{@d.literal(~:x.like(/a/))}.should raise_error(Sequel::Error)
@@ -164,27 +266,27 @@ 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(:c.as(: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
 
@@ -261,7 +363,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 +374,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
 
@@ -313,6 +415,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 +468,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 +506,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"
@@ -412,14 +523,15 @@ describe "A SQLite database" do
   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,20 +540,20 @@ 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]