sequel 3.21.0 → 3.39.0

data/spec/extensions/arbitrary_servers_spec.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "arbtirary servers" do
+  before do
+    @db = Sequel.mock(:servers=>{})
+    @db.extension :arbitrary_servers
+  end
+
+  specify "should allow arbitrary server options using a hash" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      c.opts[:host].should == 'host1'
+      c.opts[:database].should == 'db1'
+    end
+  end
+
+  specify "should not cache connections to arbitrary servers" do
+    x = nil
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      x = c
+    end
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+      c2.should_not equal(x)
+    end
+  end
+
+  specify "should yield same connection correctly when nesting" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+        c2.should equal(c)
+      end
+    end
+  end
+
+  specify "should disconnect when connection is finished" do
+    x, x1 = nil, nil
+    @db.meta_def(:disconnect_connection){|c| x = c}
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      x1 = c
+      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+        c2.should equal(c)
+      end
+      x.should equal(nil)
+    end
+    x.should equal(x1)
+  end
+
+  specify "should yield different connection correctly when nesting" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      c.opts[:host].should == 'host1'
+      @db.synchronize(:host=>'host2', :database=>'db1') do |c2|
+        c2.opts[:host].should == 'host2'
+        c2.should_not equal(c)
+      end
+    end
+  end
+
+  specify "should respect multithreaded access" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      Thread.new do
+        @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+          c2.should_not equal(c)
+        end
+      end.join
+    end
+  end
+
+  specify "should work correctly with server_block plugin" do
+    @db.extend Sequel::ServerBlock
+    @db.with_server(:host=>'host1', :database=>'db1') do
+      @db.synchronize do |c|
+        c.opts[:host].should == 'host1'
+        c.opts[:database].should == 'db1'
+        @db.synchronize do |c2|
+          c2.should equal(c)
+        end
+      end
+    end
+  end
+
+
+  specify "should respect multithreaded access with server block plugin" do
+    @db.extend Sequel::ServerBlock
+    q, q1 = Queue.new, Queue.new
+    
+    t = nil
+    @db[:t].all
+    @db.with_server(:host=>'a') do
+      @db[:t].all
+      t = Thread.new do
+        @db[:t].all
+        @db.with_server(:host=>'c') do
+          @db[:t].all
+          @db.with_server(:host=>'d'){@db[:t].all}
+          q.push nil
+          q1.pop
+          @db[:t].all
+        end
+        @db[:t].all
+      end
+      q.pop
+      @db.with_server(:host=>'b'){@db[:t].all}
+      @db[:t].all
+    end
+    @db[:t].all
+    q1.push nil
+    t.join
+    @db.sqls.should == ['SELECT * FROM t', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t -- {:host=>"d"}',
+      'SELECT * FROM t -- {:host=>"b"}', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t']
+  end
+end

data/spec/extensions/association_autoreloading_spec.rb

@@ -5,11 +5,7 @@ describe "AssociationAutoreloading plugin" do
     @c = Class.new(Sequel::Model)
     @c.plugin :association_autoreloading
     @Artist = Class.new(@c).set_dataset(:artists)
-    ds1 = @Artist.dataset
-    def ds1.fetch_rows(s)
-      (MODEL_DB.sqls ||= []) << s
-      yield({:id=>2, :name=>'Ar'})
-    end
+    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
     @Album = Class.new(@c).set_dataset(:albums)
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
@@ -22,18 +18,33 @@ describe "AssociationAutoreloading plugin" do
     album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-    MODEL_DB.reset
 
     album.artist_id = 1
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
   end
 
+  specify "should handle multiple many_to_one association with the same foreign key" do
+    @Album.many_to_one :artist2, :key=>:artist_id, :class=>@Artist
+    album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
+    album.artist
+    album.artist2
+    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1'] * 2
+
+    album.artist
+    album.artist2
+    MODEL_DB.sqls.should == []
+
+    album.artist_id = 1
+    album.artist
+    album.artist2
+    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1'] * 2
+  end
+
   specify "should not reload when value has not changed" do
     album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-    MODEL_DB.reset
 
     album.artist_id = 2
     album.artist
@@ -54,7 +65,6 @@ describe "AssociationAutoreloading plugin" do
     album.artist_id = 1
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
-    MODEL_DB.reset
 
     album.other_artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
@@ -69,7 +79,6 @@ describe "AssociationAutoreloading plugin" do
     album.artist_id = 1
     album.composite_artist
     MODEL_DB.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 1) AND (artists.name = 'Al')) LIMIT 1"]
-    MODEL_DB.reset
 
     album.name = 'Al2'
     album.composite_artist
@@ -84,7 +93,6 @@ describe "AssociationAutoreloading plugin" do
     album = salbum.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-    MODEL_DB.reset
 
     album.artist_id = 1
     album.artist

data/spec/extensions/association_dependencies_spec.rb

@@ -6,17 +6,9 @@ describe "AssociationDependencies plugin" do
     @c = Class.new(Sequel::Model)
     @c.plugin :association_dependencies
     @Artist = Class.new(@c).set_dataset(:artists)
-    ds1 = @Artist.dataset
-    def ds1.fetch_rows(s)
-      (MODEL_DB.sqls ||= []) << s
-      yield({:id=>2, :name=>'Ar'})
-    end
+    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
     @Album = Class.new(@c).set_dataset(:albums)
-    ds1 = @Album.dataset
-    def ds1.fetch_rows(s)
-      (MODEL_DB.sqls ||= []) << s
-      yield({:id=>1, :name=>'Al', :artist_id=>2})
-    end
+    @Album.dataset._fetch = {:id=>1, :name=>'Al', :artist_id=>2}
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
@@ -29,55 +21,55 @@ describe "AssociationDependencies plugin" do
   specify "should allow destroying associated many_to_one associated object" do
     @Album.add_association_dependencies :artist=>:destroy
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated many_to_one associated object" do
     @Album.add_association_dependencies :artist=>:delete
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (artists.id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE (artists.id = 2)']
   end
   
   specify "should allow destroying associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:destroy
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (position = 1)) LIMIT 1', 'DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (position = 1)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE ((albums.artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE ((albums.artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow destroying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:destroy
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
   end
   
   specify "should allow nullifying associated one_to_one objects" do
     @Artist.add_association_dependencies :first_album=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow nullifying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow nullifying associated many_to_many associations" do
     @Artist.add_association_dependencies :other_artists=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should raise an error if attempting to nullify a many_to_one association" do
@@ -105,23 +97,21 @@ describe "AssociationDependencies plugin" do
   specify "should allow specifying association dependencies in the plugin call" do
     @Album.plugin :association_dependencies, :artist=>:destroy
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should work with subclasses" do
     c = Class.new(@Album)
     c.add_association_dependencies :artist=>:destroy
     c.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
-    MODEL_DB.reset
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
 
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)']
-    MODEL_DB.reset
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1']
 
     @Album.add_association_dependencies :artist=>:destroy
     c2 = Class.new(@Album)
     c2.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 end

data/spec/extensions/association_pks_spec.rb

@@ -2,31 +2,18 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::AssociationPks" do
   before do
-    @db = MODEL_DB.clone
-    mod = Module.new do
-      def fetch_rows(sql)
-        case sql
-        when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
-          yield({:id=>1})
-          yield({:id=>2})
-          yield({:id=>3})
-        when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
-          yield({:tag_id=>1}) if $1 == '1'
-          yield({:tag_id=>2}) if $1 != '3'
-          yield({:tag_id=>3}) if $1 == '2'
-        end
+    @db = Sequel.mock(:fetch=>proc do |sql|
+      case sql
+      when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
+        [{:id=>1}, {:id=>2}, {:id=>3}]
+      when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
+        a = []
+        a << {:tag_id=>1} if $1 == '1'
+        a << {:tag_id=>2} if $1 != '3'
+        a << {:tag_id=>3} if $1 == '2'
+        a
       end
-    end
-    @db.meta_def(:dataset) do |*opts|
-      ds = super(*opts)
-      ds.extend mod
-      ds
-    end
-    def @db.transaction(opts)
-      execute('BEGIN')
-      yield
-      execute('COMMIT')
-    end
+    end)
     @Artist = Class.new(Sequel::Model(@db[:artists]))
     @Artist.columns :id
     @Album= Class.new(Sequel::Model(@db[:albums]))
@@ -37,7 +24,7 @@ describe "Sequel::Plugins::AssociationPks" do
     @Album.plugin :association_pks
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
     @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
-    @db.reset
+    @db.sqls
   end
 
   specify "should return correct associated pks for one_to_many associations" do
@@ -57,10 +44,20 @@ describe "Sequel::Plugins::AssociationPks" do
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
   end
 
+  specify "should use associated class's primary key for a one_to_many association" do
+    @Album.set_primary_key :foo
+    @Artist.load(:id=>1).album_pks = [1, 2]
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (foo IN (1, 2))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (foo NOT IN (1, 2)))"]
+  end
+
   specify "should set associated pks correctly for a many_to_many association" do
     @Album.load(:id=>2).tag_pks = [1, 3]
-    @db.sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    @db.sqls[1].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls.length.should == 3
   end
 
   specify "should use transactions if the object is configured to use transactions" do
@@ -71,15 +68,52 @@ describe "Sequel::Plugins::AssociationPks" do
       "UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))",
       "COMMIT"]
-    @db.reset
 
     album = @Album.load(:id=>2)
     album.use_transactions = true
     album.tag_pks = [1, 3]
-    @db.sqls[0].should == "BEGIN"
-    @db.sqls[1].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    @db.sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
-    @db.sqls[3].should == "COMMIT"
+    sqls = @db.sqls
+    sqls[0].should == "BEGIN"
+    sqls[1].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[2].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls[4].should == "COMMIT"
+    sqls.length.should == 5
+  end
+
+  specify "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
+    @Album.db_schema[:id][:type] = :integer
+    @Artist.load(:id=>1).album_pks = %w'1 2'
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
+  end
+
+  specify "should not automatically convert keys if the primary key is not an integer for many_to_many associations" do
+    @Album.db_schema[:id][:type] = :string
+    @Artist.load(:id=>1).album_pks = %w'1 2'
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN ('1', '2'))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN ('1', '2')))"]
+  end
+
+  specify "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
+    @Tag.db_schema[:id][:type] = :integer
+    @Album.load(:id=>2).tag_pks = %w'1 3'
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls.length.should == 3
+  end
+
+  specify "should not automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
+    @Tag.db_schema[:id][:type] = :string
+    @Album.load(:id=>2).tag_pks = %w'1 3'
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN ('1', '3')))"
+    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '1'|'1', 2)\)/
+    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '3'|'3', 2)\)/
+    sqls.length.should == 4
   end
 
 end

data/spec/extensions/association_proxies_spec.rb

@@ -31,13 +31,13 @@ describe "Sequel::Plugins::AssociationProxies" do
   
   it "should reload the cached association if sent an array method and the reload flag was given" do
     @t.select{|x| false}.should == []
-    Item.db.sqls.length == 1
+    Item.db.sqls.length.should == 1
     @t.select{|x| false}.should == []
-    Item.db.sqls.length == 1
+    Item.db.sqls.length.should == 0
     @i.tags(true).select{|x| false}.should == []
-    Item.db.sqls.length == 2
+    Item.db.sqls.length.should == 1
     @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
-    Item.db.sqls.length == 2
+    Item.db.sqls.length.should == 0
   end
   
   it "should not return a proxy object for associations that do not return an array" do

data/spec/extensions/boolean_readers_spec.rb

@@ -4,12 +4,12 @@ describe Sequel::Model, "BooleanReaders plugin" do
   before do
     @db = Sequel::Database.new({})
     def @db.schema(*args)
-      [[:id, {}], [:y, {:type=>:integer, :db_type=>'tinyint(1)'}], [:b, {:type=>:boolean, :db_type=>'boolean'}]]
+      [[:id, {}], [:z, {:type=>:integer, :db_type=>'tinyint(1)'}], [:b, {:type=>:boolean, :db_type=>'boolean'}]]
     end
 
     @c = Class.new(Sequel::Model(@db[:items]))
     @p = proc do
-      @columns = [:id, :b, :y]
+      @columns = [:id, :b, :z]
       def columns; @columns; end
     end
     @c.instance_eval(&@p)
@@ -29,7 +29,7 @@ describe Sequel::Model, "BooleanReaders plugin" do
 
   specify "should not create attribute? readers for non-boolean attributes" do
     @c.plugin(:boolean_readers)
-    proc{@c.new.y?}.should raise_error(NoMethodError)
+    proc{@c.new.z?}.should raise_error(NoMethodError)
     proc{@c.new.id?}.should raise_error(NoMethodError)
   end
 
@@ -37,17 +37,17 @@ describe Sequel::Model, "BooleanReaders plugin" do
     @c.plugin(:boolean_readers){|c| db_schema[c][:db_type] == 'tinyint(1)'}
     proc{@c.new.b?}.should raise_error(NoMethodError)
     o = @c.new
-    o.y.should == nil
-    o.y?.should == nil
-    o.y = '1'
-    o.y.should == 1
-    o.y?.should == true
-    o.y = '0'
-    o.y.should == 0
-    o.y?.should == false
-    o.y = ''
-    o.y.should == nil
-    o.y?.should == nil
+    o.z.should == nil
+    o.z?.should == nil
+    o.z = '1'
+    o.z.should == 1
+    o.z?.should == true
+    o.z = '0'
+    o.z.should == 0
+    o.z?.should == false
+    o.z = ''
+    o.z.should == nil
+    o.z?.should == nil
   end
 
   specify "should create boolean readers when set_dataset is defined" do
@@ -70,17 +70,17 @@ describe Sequel::Model, "BooleanReaders plugin" do
     c.plugin(:boolean_readers){|x| db_schema[x][:db_type] == 'tinyint(1)'}
     c.set_dataset(@db[:a])
     o = c.new
-    o.y.should == nil
-    o.y?.should == nil
-    o.y = '1'
-    o.y.should == 1
-    o.y?.should == true
-    o.y = '0'
-    o.y.should == 0
-    o.y?.should == false
-    o.y = ''
-    o.y.should == nil
-    o.y?.should == nil
+    o.z.should == nil
+    o.z?.should == nil
+    o.z = '1'
+    o.z.should == 1
+    o.z?.should == true
+    o.z = '0'
+    o.z.should == 0
+    o.z?.should == false
+    o.z = ''
+    o.z.should == nil
+    o.z?.should == nil
     proc{o.b?}.should raise_error(NoMethodError)
   end