sequel 3.14.0 → 3.15.0

data/spec/adapters/sqlite_spec.rb

@@ -9,8 +9,10 @@ INTEGRATION_DB = SQLITE_DB unless defined?(INTEGRATION_DB)
 context "An SQLite database" do
   before do
     @db = SQLITE_DB
+    @fk = @db.foreign_keys
   end
   after do
+    @db.foreign_keys = @fk
     Sequel.datetime_class = Time
   end
 
@@ -325,13 +327,41 @@ context "A SQLite database" do
     @db[:test3] << { :name => "foo", :value => 2}
     @db[:test3] << { :name => "foo", :value => 3}
     @db[:test3].filter(:id => 2).delete
-    
+
     @db.drop_column :test3, :value
 
     @db['PRAGMA table_info(?)', :test3][:id][:pk].to_i.should == 1
     @db[:test3].select(:id).all.should == [{:id => 1}, {:id => 3}]
   end
 
+  if SQLITE_DB.foreign_keys
+    specify "should keep foreign keys when dropping a column" do
+      @db.create_table! :test do
+        primary_key :id
+        String :name
+        Integer :value
+      end
+      @db.create_table! :test3 do
+        String :name
+        Integer :value
+        foreign_key :test_id, :test, :on_delete => :set_null, :on_update => :cascade
+      end
+
+      @db[:test3].insert(:name => "abc", :test_id => @db[:test].insert(:name => "foo", :value => 3))
+      @db[:test3].insert(:name => "def", :test_id => @db[:test].insert(:name => "bar", :value => 4))
+
+      @db.drop_column :test3, :value
+
+      @db[:test].filter(:name => 'bar').delete
+      @db[:test3][:name => 'def'][:test_id].should be_nil
+
+      @db[:test].filter(:name => 'foo').update(:id=>100)
+      @db[:test3][:name => 'abc'][:test_id].should == 100
+
+      @db.drop_table :test, :test3
+    end
+  end
+
   specify "should support rename_column operations" do
     @db[:test2].delete
     @db.add_column :test2, :xyz, :text

data/spec/core/dataset_spec.rb

@@ -113,7 +113,7 @@ context "Dataset#clone" do
     @dataset.row_proc = Proc.new{|r| r}
     @clone = @dataset.clone
 
-    @clone.should_not === @dataset
+    @clone.object_id.should_not === @dataset.object_id
     @clone.class.should == @dataset.class
     @clone.opts.should == @dataset.opts
     @clone.row_proc.should == @dataset.row_proc
@@ -159,6 +159,58 @@ context "Dataset#clone" do
   end
 end
 
+context "Dataset#==" do
+  before do
+    @db = MockDatabase.new
+    @h = {}
+  end
+  
+  specify "should be the true for dataset with the same db, opts, and SQL" do
+    @db[:t].should == @db[:t]
+  end
+
+  specify "should be different for datasets with different dbs" do
+    @db[:t].should_not == MockDatabase.new[:t]
+  end
+  
+  specify "should be different for datasets with different opts" do
+    @db[:t].should_not == @db[:t].clone(:blah=>1)
+  end
+  
+  specify "should be different for datasets with different SQL" do
+    ds = @db[:t]
+    ds.quote_identifiers = true
+    ds.should_not == @db[:t]
+  end
+end
+
+context "Dataset#hash" do
+  before do
+    @db = MockDatabase.new
+    @h = {}
+  end
+  
+  specify "should be the same for dataset with the same db, opts, and SQL" do
+    @db[:t].hash.should == @db[:t].hash
+    @h[@db[:t]] = 1
+    @h[@db[:t]].should == 1
+  end
+
+  specify "should be different for datasets with different dbs" do
+    @db[:t].hash.should_not == MockDatabase.new[:t].hash
+  end
+  
+  specify "should be different for datasets with different opts" do
+    @db[:t].hash.should_not == @db[:t].clone(:blah=>1).hash
+  end
+  
+  specify "should be different for datasets with different SQL" do
+    ds = @db[:t]
+    ds.quote_identifiers = true
+    ds.hash.should_not == @db[:t].hash
+  end
+end
+
 context "A simple dataset" do
   before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
@@ -2073,6 +2125,14 @@ context "Dataset#join_table" do
     @d.join(:categories, :a=>:d){|j,lj,js| :b.qualify(j) > :c.qualify(lj)}.sql.should ==
       'SELECT * FROM "items" INNER JOIN "categories" ON (("categories"."a" = "items"."d") AND ("categories"."b" > "items"."c"))'
   end
+
+  specify "should prefer explicit aliases over implicit" do
+    @d.from(:items___i).join(:categories___c, {:category_id => :id}, {:table_alias=>:c2, :implicit_qualifier=>:i2}).sql.should ==
+      'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
+    @d.from(:items.as(:i)).join(:categories.as(:c), {:category_id => :id}, {:table_alias=>:c2, :implicit_qualifier=>:i2}).sql.should ==
+      'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
+  end
+  
   
   specify "should not allow insert, update, delete, or truncate" do
     proc{@d.join(:categories, :a=>:d).insert_sql}.should raise_error(Sequel::InvalidOperation)

data/spec/core/spec_helper.rb

@@ -1,4 +1,5 @@
 require 'rubygems'
+
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
   require 'sequel/core'

data/spec/extensions/active_model_spec.rb

@@ -45,10 +45,17 @@ describe "ActiveModel plugin" do
         assert_equal nil, @m.to_key
         @o.id = 1
         assert_equal [1], @o.to_key
+        @o.id = nil
+        assert_equal nil, @o.to_key
+
         @c.set_primary_key [:id2, :id]
+        assert_equal nil, @o.to_key
+        @o.id = 1
         @o.id2 = 2
         assert_equal [2, 1], @o.to_key
         @o.destroy
+        assert_equal [2, 1], @o.to_key
+        @o.id = nil
         assert_equal nil, @o.to_key
       end
       
@@ -84,6 +91,9 @@ describe "ActiveModel plugin" do
     else
       res = ::Test::Unit::TestResult.new
       tc.suite.run(res){}
+      if res.failure_count > 0
+        puts res.instance_variable_get(:@failures)
+      end
       res.failure_count.should == 0
     end
   end

data/spec/extensions/lazy_attributes_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::LazyAttributes" do
   before do
-    class ::LazyAttributesModel < Sequel::Model(:la)
+    @db = MockDatabase.new
+    @db.meta_def(:schema){|*a| [[:id, {:type=>:integer}], [:name,{:type=>:string}]]}
+    class ::LazyAttributesModel < Sequel::Model(@db[:la])
       plugin :lazy_attributes
       set_columns([:id, :name])
       meta_def(:columns){[:id, :name]}
@@ -36,7 +38,7 @@ describe "Sequel::Plugins::LazyAttributes" do
     end
     @c = ::LazyAttributesModel
     @ds = LazyAttributesModel.dataset
-    MODEL_DB.reset
+    @db.reset
   end
   after do
     Object.send(:remove_const, :LazyAttributesModel)
@@ -63,13 +65,19 @@ describe "Sequel::Plugins::LazyAttributes" do
     @ds.sql.should == 'SELECT id FROM la'
   end
 
+  it "should still typecast correctly in lazy loaded column setters" do
+    m = @c.new
+    m.name = 1
+    m.name.should == '1'
+  end
+
   it "should lazily load the attribute for a single model object if there is an active identity map" do
     @c.with_identity_map do
       m = @c.first
       m.values.should == {:id=>1}
       m.name.should == '1'
       m.values.should == {:id=>1, :name=>'1'}
-      MODEL_DB.sqls.should == ['SELECT id FROM la LIMIT 1', 'SELECT name FROM la WHERE (id = 1) LIMIT 1']
+      @db.sqls.should == ['SELECT id FROM la LIMIT 1', 'SELECT name FROM la WHERE (id = 1) LIMIT 1']
     end
   end
 
@@ -78,7 +86,7 @@ describe "Sequel::Plugins::LazyAttributes" do
     m.values.should == {:id=>1}
     m.name.should == '1'
     m.values.should == {:id=>1, :name=>'1'}
-    MODEL_DB.sqls.should == ['SELECT id FROM la LIMIT 1', 'SELECT name FROM la WHERE (id = 1) LIMIT 1']
+    @db.sqls.should == ['SELECT id FROM la LIMIT 1', 'SELECT name FROM la WHERE (id = 1) LIMIT 1']
   end
 
   it "should not lazily load the attribute for a single model object if the value already exists" do
@@ -88,7 +96,7 @@ describe "Sequel::Plugins::LazyAttributes" do
       m[:name] = '1'
       m.name.should == '1'
       m.values.should == {:id=>1, :name=>'1'}
-      MODEL_DB.sqls.should == ['SELECT id FROM la LIMIT 1']
+      @db.sqls.should == ['SELECT id FROM la LIMIT 1']
     end
   end
 
@@ -97,7 +105,7 @@ describe "Sequel::Plugins::LazyAttributes" do
       m = @c.new
       m.values.should == {}
       m.name.should == nil
-      MODEL_DB.sqls.should == []
+      @db.sqls.should == []
     end
   end
 
@@ -107,7 +115,7 @@ describe "Sequel::Plugins::LazyAttributes" do
       ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
       ms.map{|m| m.name}.should == %w'1 2'
       ms.map{|m| m.values}.should == [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
-      MODEL_DB.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
+      @db.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
     end
   end
 
@@ -122,7 +130,7 @@ describe "Sequel::Plugins::LazyAttributes" do
       ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
       ms.map{|m| m.name}.should == %w'1-blah 2-blah'
       ms.map{|m| m.values}.should == [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
-      MODEL_DB.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
+      @db.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
     end
   end
 
@@ -136,9 +144,9 @@ describe "Sequel::Plugins::LazyAttributes" do
       ms.map{|m| m.values}.should == [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}]
       ms.map{|m| m.deserialized_values}.should == [{:name=>3}, {:name=>6}]
       ms.map{|m| m.name}.should == [3,6]
-      MODEL_DB.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
+      @db.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
     end
-    MODEL_DB.reset
+    @db.reset
     @c.with_identity_map do
       m = @ds.first
       m.values.should == {:id=>1}
@@ -146,7 +154,7 @@ describe "Sequel::Plugins::LazyAttributes" do
       m.values.should == {:id=>1, :name=>"--- 3\n"}
       m.deserialized_values.should == {:name=>3}
       m.name.should == 3
-      MODEL_DB.sqls.should == ["SELECT id FROM la LIMIT 1", "SELECT name FROM la WHERE (id = 1) LIMIT 1"]
+      @db.sqls.should == ["SELECT id FROM la LIMIT 1", "SELECT name FROM la WHERE (id = 1) LIMIT 1"]
     end
   end
 end

data/spec/extensions/named_timezones_spec.rb

@@ -35,32 +35,34 @@ describe "Sequel named_timezones extension" do
     Sequel.database_timezone.should == @tz_out
   end
     
-  it "should convert datetimes going into the database to named database_timezone" do
-    ds = @db[:a]
-    def ds.supports_timestamp_timezones?; true; end
-    def ds.supports_timestamp_usecs?; false; end
-    ds.insert([@dt, DateTime.civil(2009,6,1,3,20,30,Rational(-7, 24)), DateTime.civil(2009,6,1,6,20,30,Rational(-1, 6))])
-    @db.sqls.should == ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
+  unless RUBY_VERSION == '1.8.6' && RUBY_PLATFORM =~ /win/
+    it "should convert datetimes going into the database to named database_timezone" do
+      ds = @db[:a]
+      def ds.supports_timestamp_timezones?; true; end
+      def ds.supports_timestamp_usecs?; false; end
+      ds.insert([@dt, DateTime.civil(2009,6,1,3,20,30,-7/24.0), DateTime.civil(2009,6,1,6,20,30,-1/6.0)])
+      @db.sqls.should == ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
+    end
   end
   
   it "should convert datetimes coming out of the database from database_timezone to application_timezone" do
     dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30-0400')
     dt.should == @dt
-    dt.offset.should == Rational(-7, 24)
+    dt.offset.should == -7/24.0
     
     dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30+0000')
     dt.should == @dt
-    dt.offset.should == Rational(-7, 24)
+    dt.offset.should == -7/24.0
   end
     
   it "should assume datetimes coming out of the database that don't have an offset as coming from database_timezone" do
     dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30')
     dt.should == @dt
-    dt.offset.should == Rational(-7, 24)
+    dt.offset.should == -7/24.0
     
     dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30')
-    dt.should == @dt + Rational(1, 6)
-    dt.offset.should == Rational(-7, 24)
+    dt.should == @dt + 1/6.0
+    dt.offset.should == -7/24.0
   end
   
   it "should work with the thread_local_timezones extension" do

data/spec/extensions/spec_helper.rb

@@ -63,11 +63,7 @@ class MockDatabase < Sequel::Database
   end
 
   def schema(table_name, opts)
-    if table_name
-      [[:id, {:primary_key=>true}]]
-    else
-      {table_name=>[[:id, {:primary_key=>true}]]}
-    end
+    [[:id, {:primary_key=>true}]]
   end
 
   def transaction(opts={}); yield; end

data/spec/integration/associations_test.rb

@@ -157,6 +157,29 @@ describe "Sequel::Model Simple Associations" do
     [:Tag, :Album, :Artist].each{|x| Object.send(:remove_const, x)}
   end
   
+  specify "should handle aliased tables when eager_graphing" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    
+    Artist.set_dataset(:artists___ar)
+    Album.set_dataset(:albums___a)
+    Tag.set_dataset(:tags___t)
+    Artist.one_to_many :balbums, :class=>Album, :key=>:artist_id
+    Album.many_to_many :btags, :class=>Tag, :join_table=>:albums_tags, :right_key=>:tag_id
+    Album.many_to_one :bartist, :class=>Artist, :key=>:artist_id
+    Tag.many_to_many :balbums, :class=>Album, :join_table=>:albums_tags, :right_key=>:album_id
+
+    a = Artist.eager_graph(:balbums=>:btags).all
+    a.should == [@artist]
+    a.first.balbums.should == [@album]
+    a.first.balbums.first.btags.should == [@tag]
+    
+    a = Tag.eager_graph(:balbums=>:bartist).all
+    a.should == [@tag]
+    a.first.balbums.should == [@album]
+    a.first.balbums.first.bartist.should == @artist
+  end
+  
   it_should_behave_like "regular and composite key associations"
 
   specify "should have add method accept hashes and create new records" do

data/spec/integration/dataset_test.rb

@@ -44,7 +44,7 @@ describe "Simple Dataset operations" do
     @ds.all.should == [{:id=>1, :number=>11}]
   end
   
-  cspecify "should have update return the number of matched rows", [:mysql, :mysql], [:do, :mysql], [:ado] do
+  cspecify "should have update return the number of matched rows", [:mysql, :mysql], [:do, :mysql], [:mysql2], [:ado] do
     @ds.update(:number=>:number).should == 1
     @ds.filter(:id=>1).update(:number=>:number).should == 1
     @ds.filter(:id=>2).update(:number=>:number).should == 0
@@ -475,7 +475,7 @@ describe Sequel::SQL::Constants do
     Date.today.should == @c2[@ds.get(:d)]
   end
 
-  cspecify "should have working CURRENT_TIME", [:do, :mysql], [:jdbc, :sqlite] do
+  cspecify "should have working CURRENT_TIME", [:do, :mysql], [:jdbc, :sqlite], [:mysql2] do
     @db.create_table!(:constants){Time :t, :only_time=>true}
     @ds.insert(:t=>Sequel::CURRENT_TIME)
     (Time.now - @c[@ds.get(:t)]).should be_close(0, 1)
@@ -925,7 +925,7 @@ describe "Dataset identifier methods" do
     @db.drop_table(:a)
   end
   
-  it "#identifier_output_method should change how identifiers are output" do
+  cspecify "#identifier_output_method should change how identifiers are output", [:mysql2] do
     @ds.identifier_output_method = :upcase
     @ds.first.should == {:AB=>1}
     @ds.identifier_output_method = :uprev

data/spec/integration/plugin_test.rb

@@ -275,6 +275,12 @@ describe "Lazy Attributes plugin" do
     Item.first.num.should == 1
   end
   
+  specify "should typecast lazy attribute in setter" do
+    i = Item.new
+    i.num = '1'
+    i.num.should == 1
+  end
+  
   specify "should load lazy attribute for all items returned when accessing any item if using identity map " do
     Item.create(:name=>'K', :num=>2)
     Item.with_identity_map do

data/spec/integration/schema_test.rb

@@ -33,6 +33,13 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items, :reload=>true)
   end
 
+  specify "Model schema should include columns in the table, even if they aren't selected" do
+    INTEGRATION_DB.create_table!(:items){String :a; Integer :number}
+    m = Sequel::Model(INTEGRATION_DB[:items].select(:a))
+    m.columns.should == [:a]
+    m.db_schema[:number][:type].should == :integer
+  end
+
   specify "should raise an error when the table doesn't exist" do
     proc{INTEGRATION_DB.schema(:no_table)}.should raise_error(Sequel::Error)
   end

data/spec/integration/timezone_test.rb

@@ -14,8 +14,8 @@ describe "Sequel timezone support" do
     end
 
     Sequel.datetime_class = DateTime
-    local_dst_offset = Rational(Time.local(2010, 6).utc_offset, 60*60*24)
-    local_std_offset = Rational(Time.local(2010, 1).utc_offset, 60*60*24)
+    local_dst_offset = Time.local(2010, 6).utc_offset/86400.0
+    local_std_offset = Time.local(2010, 1).utc_offset/86400.0
     [DateTime.now, DateTime.civil(2010,1,1,12,0,0,local_std_offset), DateTime.civil(2010,6,1,12,0,0,local_dst_offset)].each do |dt|
       @db[:t].insert(dt)
       dt2 = @db[:t].single_value

data/spec/integration/type_test.rb

@@ -78,7 +78,7 @@ describe "Supported types" do
     ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
   end
   
-  cspecify "should support generic file type", [:do], [:odbc, :mssql] do
+  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2] do
     ds = create_items_table_with_column(:name, File)
     ds.insert(:name => ("a\0"*300).to_sequel_blob)
     ds.all.should == [{:name=>("a\0"*300).to_sequel_blob}]

data/spec/model/associations_spec.rb

@@ -1903,6 +1903,13 @@ describe Sequel::Model, "many_to_many" do
     a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attribute2node ON ((attribute2node.attributeid = attributes.id) AND (attribute2node.nodeid = 1234))'
   end
   
+  it "should handle an aliased join table when eager loading" do
+    r = @c2.many_to_many(:attributes, :class => @c1, :join_table => :attribute2node___attributes_nodes)
+    
+    a = @c2.eager_loading_dataset(r, @c2.dataset, [:id], nil)
+    a.sql.should == 'SELECT id, attributes_nodes.node_id AS x_foreign_key_x FROM nodes'
+  end
+  
   it "should support a conditions option" do
     @c2.many_to_many :attributes, :class => @c1, :conditions => {:a=>32}
     n = @c2.new(:id => 1234)