sequel 3.21.0 → 3.36.0

data/spec/{core/core_sql_spec.rb → extensions/core_extensions_spec.rb}

@@ -1,28 +1,106 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
-describe "Array#all_two_pairs?" do
-  specify "should return false if empty" do
-    [].all_two_pairs?.should == false
+describe "Sequel core extensions" do
+  specify "should not be used inside Sequel, to insure Sequel works without them" do
+    usage = []
+    match_re = /(\.(sql_value_list|sql_array|sql_expr|sql_negate|sql_or|sql_string_join|lit|to_sequel_blob|case)\W)|:\w+\.(qualify|identifier|as|cast|asc|desc|sql_subscript|\*|sql_function)\W/
+    comment_re = /^\s*#|# core_sql/
+    Dir['lib/sequel/**/*.rb'].each do |f|
+      lines = File.read(f).split("\n").grep(match_re).delete_if{|l| l =~ comment_re}
+      usage << [f, lines] unless lines.empty?
+    end
+    puts usage unless usage.empty?
+    usage.should be_empty
   end
 
-  specify "should return false if any of the elements is not an array" do
-    [1].all_two_pairs?.should == false
-    [[1,2],1].all_two_pairs?.should == false
+  specify "should have Sequel.core_extensions? be true if enabled" do
+    Sequel.core_extensions?.should be_true
   end
+end
 
-  specify "should return false if any of the elements has a length other than two" do
-    [[1,2],[]].all_two_pairs?.should == false
-    [[1,2],[1]].all_two_pairs?.should == false
-    [[1,2],[1,2,3]].all_two_pairs?.should == false
+describe "Array and Hash extensions" do
+  before do
+    db = Sequel::Database.new
+    @d = db[:items]
+    def @d.l(*args, &block)
+      literal(filter_expr(*args, &block))
+    end
+    def @d.lit(*args)
+      literal(*args)
+    end
   end
-
-  specify "should return true if all of the elements are arrays with a length of two" do
-    [[1,2]].all_two_pairs?.should == true
-    [[1,2],[1,2]].all_two_pairs?.should == true
-    [[1,2],[1,2],[1,2]].all_two_pairs?.should == true
+  
+  it "should support sql_expr on arrays with all two pairs" do
+    @d.l([[:x, 100],[:y, 'a']].sql_expr).should == '((x = 100) AND (y = \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_expr).should == '((x IS TRUE) AND (y IS FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_expr).should == '((x IS NULL) AND (y IN (1, 2, 3)))'
+  end
+  
+  it "should support sql_negate on arrays with all two pairs" do
+    @d.l([[:x, 100],[:y, 'a']].sql_negate).should == '((x != 100) AND (y != \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_negate).should == '((x IS NOT TRUE) AND (y IS NOT FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_negate).should == '((x IS NOT NULL) AND (y NOT IN (1, 2, 3)))'
+  end
+  
+  it "should support ~ on arrays with all two pairs" do
+    @d.l(~[[:x, 100],[:y, 'a']]).should == '((x != 100) OR (y != \'a\'))'
+    @d.l(~[[:x, true], [:y, false]]).should == '((x IS NOT TRUE) OR (y IS NOT FALSE))'
+    @d.l(~[[:x, nil], [:y, [1,2,3]]]).should == '((x IS NOT NULL) OR (y NOT IN (1, 2, 3)))'
+  end
+  
+  it "should support sql_or on arrays with all two pairs" do
+    @d.l([[:x, 100],[:y, 'a']].sql_or).should == '((x = 100) OR (y = \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_or).should == '((x IS TRUE) OR (y IS FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_or).should == '((x IS NULL) OR (y IN (1, 2, 3)))'
+  end
+  
+  it "should support Array#sql_string_join for concatenation of SQL strings" do
+    @d.lit([:x].sql_string_join).should == '(x)'
+    @d.lit([:x].sql_string_join(', ')).should == '(x)'
+    @d.lit([:x, :y].sql_string_join).should == '(x || y)'
+    @d.lit([:x, :y].sql_string_join(', ')).should == "(x || ', ' || y)"
+    @d.lit([:x.sql_function(1), :y.sql_subscript(1)].sql_string_join).should == '(x(1) || y[1])'
+    @d.lit([:x.sql_function(1), 'y.z'.lit].sql_string_join(', ')).should == "(x(1) || ', ' || y.z)"
+    @d.lit([:x, 1, :y].sql_string_join).should == "(x || '1' || y)"
+    @d.lit([:x, 1, :y].sql_string_join(', ')).should == "(x || ', ' || '1' || ', ' || y)"
+    @d.lit([:x, 1, :y].sql_string_join(:y__z)).should == "(x || y.z || '1' || y.z || y)"
+    @d.lit([:x, 1, :y].sql_string_join(1)).should == "(x || '1' || '1' || '1' || y)"
+    @d.lit([:x, :y].sql_string_join('y.x || x.y'.lit)).should == "(x || y.x || x.y || y)"
+    @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).should == "(x || y || a || b)"
+  end
+
+  it "should support sql_expr on hashes" do
+    @d.l({:x => 100, :y => 'a'}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x = 100)', '(y = \'a\')']
+    @d.l({:x => true, :y => false}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
+  end
+  
+  it "should support sql_negate on hashes" do
+    @d.l({:x => 100, :y => 'a'}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x != 100)', '(y != \'a\')']
+    @d.l({:x => true, :y => false}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
+  end
+  
+  it "should support ~ on hashes" do
+    @d.l(~{:x => 100, :y => 'a'})[1...-1].split(' OR ').sort.should == ['(x != 100)', '(y != \'a\')']
+    @d.l(~{:x => true, :y => false})[1...-1].split(' OR ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
+    @d.l(~{:x => nil, :y => [1,2,3]})[1...-1].split(' OR ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
+  end
+  
+  it "should support sql_or on hashes" do
+    @d.l({:x => 100, :y => 'a'}.sql_or)[1...-1].split(' OR ').sort.should == ['(x = 100)', '(y = \'a\')']
+    @d.l({:x => true, :y => false}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
   end
-end
   
+  it "should Hash#& and Hash#|" do
+    @d.l({:y => :z} & :x).should == '((y = z) AND x)'
+    @d.l({:x => :a} & {:y => :z}).should == '((x = a) AND (y = z))'
+    @d.l({:y => :z} | :x).should == '((y = z) OR x)'
+    @d.l({:x => :a} | {:y => :z}).should == '((x = a) OR (y = z))'
+  end
+end
+
 describe "Array#case and Hash#case" do
   before do
     @d = Sequel::Dataset.new(nil)
@@ -75,16 +153,16 @@ end
 
 describe "String#lit" do
   before do
-    @ds = ds = MockDatabase.new.dataset
+    @ds = ds = Sequel::Database.new[:t]
   end
+
   specify "should return an LiteralString object" do
     'xyz'.lit.should be_a_kind_of(Sequel::LiteralString)
     'xyz'.lit.to_s.should == 'xyz'
   end
   
   specify "should inhibit string literalization" do
-    Sequel::Database.new[:t].update_sql(:stamp => "NOW()".lit).should == \
-      "UPDATE t SET stamp = NOW()"
+    @ds.update_sql(:stamp => "NOW()".lit).should == "UPDATE t SET stamp = NOW()"
   end
 
   specify "should return a PlaceholderLiteralString object if args are given" do
@@ -176,10 +254,10 @@ end
 
 describe "Column references" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      def quoted_identifier(c); "`#{c}`"; end
+    @ds = Sequel::Database.new.dataset
+    def @ds.quoted_identifier_append(sql, c)
+      sql << "`#{c}`"
     end
-    @ds = @c.new(MockDatabase.new)
     @ds.quote_identifiers = true
   end
   
@@ -285,57 +363,22 @@ describe "Symbol" do
     @oe.class.should == Sequel::SQL::OrderedExpression
     @oe.descending.should == false
   end
-end
 
-describe "Dataset#literal" do
-  before do
-    @ds = MockDataset.new(nil)
-  end
-  
-  specify "should convert qualified symbol notation into dot notation" do
-    @ds.literal(:abc__def).should == 'abc.def'
-  end
-  
-  specify "should convert AS symbol notation into SQL AS notation" do
-    @ds.literal(:xyz___x).should == 'xyz AS x'
-    @ds.literal(:abc__def___x).should == 'abc.def AS x'
-  end
-  
-  specify "should support names with digits" do
-    @ds.literal(:abc2).should == 'abc2'
-    @ds.literal(:xx__yy3).should == 'xx.yy3'
-    @ds.literal(:ab34__temp3_4ax).should == 'ab34.temp3_4ax'
-    @ds.literal(:x1___y2).should == 'x1 AS y2'
-    @ds.literal(:abc2__def3___ggg4).should == 'abc2.def3 AS ggg4'
-  end
-  
-  specify "should support upper case and lower case" do
-    @ds.literal(:ABC).should == 'ABC'
-    @ds.literal(:Zvashtoy__aBcD).should == 'Zvashtoy.aBcD'
-  end
-
-  specify "should support spaces inside column names" do
-    @ds.quote_identifiers = true
-    @ds.literal(:"AB C").should == '"AB C"'
-    @ds.literal(:"Zvas htoy__aB cD").should == '"Zvas htoy"."aB cD"'
-    @ds.literal(:"aB cD___XX XX").should == '"aB cD" AS "XX XX"'
-    @ds.literal(:"Zva shtoy__aB cD___XX XX").should == '"Zva shtoy"."aB cD" AS "XX XX"'
+  specify "should work correctly with objects" do
+    o = Object.new
+    def o.sql_literal(ds) "(foo)" end
+    @ds.literal(:column.qualify(o)).should == '(foo)."COLUMN"'
   end
 end
 
 describe "Symbol" do
   before do
-    @ds = Sequel::Dataset.new(MockDatabase.new)
+    @ds = Sequel::Database.new.dataset
   end
   
-  specify "should support upper case outer functions" do
+  specify "should support sql_function method" do
     :COUNT.sql_function('1').to_s(@ds).should == "COUNT('1')"
-  end
-  
-  specify "should inhibit string literalization" do
-    db = Sequel::Database.new
-    ds = db[:t]
-    ds.select(:COUNT.sql_function('1')).sql.should == "SELECT COUNT('1') FROM t"
+    @ds.select(:COUNT.sql_function('1')).sql.should == "SELECT COUNT('1')"
   end
   
   specify "should support cast method" do
@@ -346,6 +389,7 @@ describe "Symbol" do
     @ds.literal(:abc.sql_subscript(1)).should == "abc[1]"
     @ds.literal(:abc__def.sql_subscript(1)).should == "abc.def[1]"
     @ds.literal(:abc.sql_subscript(1)|2).should == "abc[1, 2]"
+    @ds.literal(:abc.sql_subscript(1)[2]).should == "abc[1][2]"
   end
 
   specify "should support cast_numeric and cast_string" do
@@ -367,85 +411,21 @@ describe "Symbol" do
   end
   
   specify "should allow database independent types when casting" do
-    m = MockDatabase.new
-    m.instance_eval do
-       def cast_type_literal(type)
-         return :foo if type == Integer
-         return :bar if type == String
-         type
-       end
+    db = @ds.db
+    def db.cast_type_literal(type)
+      return :foo if type == Integer
+      return :bar if type == String
+      type
     end
-    @ds2 = Sequel::Dataset.new(m)
-    :abc.cast(String).to_s(@ds).should == "CAST(abc AS varchar(255))"
-    :abc.cast(String).to_s(@ds2).should == "CAST(abc AS bar)"
-    :abc.cast(String).to_s(@ds2).should == "CAST(abc AS bar)"
-    :abc.cast_string.to_s(@ds2).should == "CAST(abc AS bar)"
-    :abc.cast_string(Integer).to_s(@ds2).should == "CAST(abc AS foo)"
-    :abc.cast_numeric.to_s(@ds2).should == "CAST(abc AS foo)"
-    :abc.cast_numeric(String).to_s(@ds2).should == "CAST(abc AS bar)"
+    :abc.cast(String).to_s(@ds).should == "CAST(abc AS bar)"
+    :abc.cast(String).to_s(@ds).should == "CAST(abc AS bar)"
+    :abc.cast_string.to_s(@ds).should == "CAST(abc AS bar)"
+    :abc.cast_string(Integer).to_s(@ds).should == "CAST(abc AS foo)"
+    :abc.cast_numeric.to_s(@ds).should == "CAST(abc AS foo)"
+    :abc.cast_numeric(String).to_s(@ds).should == "CAST(abc AS bar)"
   end
 
   specify "should support SQL EXTRACT function via #extract " do
     :abc.extract(:year).to_s(@ds).should == "extract(year FROM abc)"
   end
 end
-
-describe "Sequel::SQL::Function#==" do
-  specify "should be true for functions with the same name and arguments, false otherwise" do
-    a = :date.sql_function(:t)
-    b = :date.sql_function(:t)
-    a.should == b
-    (a == b).should == true
-    c = :date.sql_function(:c)
-    a.should_not == c
-    (a == c).should == false
-    d = :time.sql_function(:c)
-    a.should_not == d
-    c.should_not == d
-    (a == d).should == false
-    (c == d).should == false
-  end
-end
-
-describe "Sequel::SQL::OrderedExpression" do
-  specify "should #desc" do
-    @oe = :column.asc
-    @oe.descending.should == false
-    @oe.desc.descending.should == true
-  end
-
-  specify "should #asc" do
-    @oe = :column.desc
-    @oe.descending.should == true
-    @oe.asc.descending.should == false
-  end
-
-  specify "should #invert" do
-    @oe = :column.desc
-    @oe.invert.descending.should == false
-    @oe.invert.invert.descending.should == true
-  end
-end
-
-describe "Expression" do
-  specify "should consider objects == only if they have the same attributes" do
-    :column.qualify(:table).cast(:type).*(:numeric_column).asc.should == :column.qualify(:table).cast(:type).*(:numeric_column).asc
-    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.should_not == :column.qualify(:table).cast(:type).*(:numeric_column).asc
-
-    :column.qualify(:table).cast(:type).*(:numeric_column).asc.should eql(:column.qualify(:table).cast(:type).*(:numeric_column).asc)
-    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.should_not eql(:column.qualify(:table).cast(:type).*(:numeric_column).asc)
-  end
-
-  specify "should use the same hash value for objects that have the same attributes" do
-    :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash.should == :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash
-    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.hash.should_not == :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash
-
-    h = {}
-    a = :column.qualify(:table).cast(:type).*(:numeric_column).asc
-    b = :column.qualify(:table).cast(:type).*(:numeric_column).asc
-    h[a] = 1
-    h[b] = 2
-    h[a].should == 2
-    h[b].should == 2
-  end
-end

data/spec/extensions/dataset_associations_spec.rb

@@ -0,0 +1,199 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DatasetAssociations" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.columns :id, :name
+    @Album.columns :id, :name, :artist_id
+    @Tag.columns :id, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album
+    @Artist.one_to_one :first_album, :class=>@Album
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag
+    @Tag.many_to_many :albums, :class=>@Album
+    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    ds = @Album.artists
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    ds = @Artist.albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    ds = @Artist.first_albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    ds = @Album.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should work for many_through_many associations" do
+    ds = @Artist.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should have an associated method that takes an association symbol" do
+    ds = @Album.associated(:artist)
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should raise an Error if an invalid association is given to associated" do
+    proc{@Album.associated(:foo)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an Error if an unrecognized association type is used" do
+    @Album.association_reflection(:artist)[:type] = :foo
+    proc{@Album.artists}.should raise_error(Sequel::Error)
+  end
+
+  it "should work correctly when chaining" do
+    ds = @Artist.albums.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
+  end
+
+  it "should deal correctly with filters before the association method" do
+    @Artist.filter(:id=>1).albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists WHERE (id = 1)))"
+  end
+
+  it "should deal correctly with filters after the association method" do
+    @Artist.albums.filter(:id=>1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with block on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums do |ds| ds.filter(:id=>1..100) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :conditions option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :conditions=>{:id=>1..100}
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :distinct option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :distinct=>true
+    @Artist.albums.sql.should == "SELECT DISTINCT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should deal correctly with :eager option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager=>:tags
+    @Artist.albums.opts[:eager].should == {:tags=>nil}
+  end
+
+  it "should deal correctly with :eager_block option on the association, ignoring the association block" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager_block=>proc{|ds| ds.filter(:id=>1..100)} do |ds| ds.filter(:id=>2..200) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :extend option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :extend=>Module.new{def foo(x) filter(:id=>x) end}
+    @Artist.albums.foo(1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with :order option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :order=>:name
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists)) ORDER BY name"
+  end
+
+  it "should deal correctly with :select option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :select=>[:id, :name]
+    @Artist.albums.sql.should == "SELECT id, name FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+end
+
+describe "Sequel::Plugins::DatasetAssociations with composite keys" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.set_primary_key([:id1, :id2])
+    @Album.set_primary_key([:id1, :id2])
+    @Tag.set_primary_key([:id1, :id2])
+
+    @Artist.columns :id1, :id2, :name
+    @Album.columns :id1, :id2, :name, :artist_id1, :artist_id2
+    @Tag.columns :id1, :id2, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Artist.one_to_one :first_album, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_many :tags, :class=>@Tag, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
+    @Tag.many_to_many :albums, :class=>@Album, :right_key=>[:album_id1, :album_id2], :left_key=>[:tag_id1, :tag_id2]
+    @Artist.many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    @Album.artists.sql.should == "SELECT * FROM artists WHERE ((artists.id1, artists.id2) IN (SELECT albums.artist_id1, albums.artist_id2 FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    @Artist.first_albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    @Album.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work for many_through_many associations" do
+    @Artist.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work correctly when chaining" do
+    @Artist.albums.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))"
+  end
+end

data/spec/extensions/defaults_setter_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DefaultsSetter" do
+  before do
+    @db = db = Sequel::Database.new
+    @c = c = Class.new(Sequel::Model(db[:foo]))
+    @c.instance_variable_set(:@db_schema, {:a=>{}})
+    @c.plugin :defaults_setter
+    @c.columns :a
+    @pr = proc{|x| db.meta_def(:schema){|*| [[:a, {:ruby_default => x}]]}; c.dataset = c.dataset; c}
+  end
+
+  it "should set default value upon initialization" do
+    @pr.call(2).new.values.should == {:a=>2}
+  end
+
+  it "should not mark the column as modified" do
+    @pr.call(2).new.changed_columns.should == []
+  end
+
+  it "should not set a default of nil" do
+    @pr.call(nil).new.values.should == {}
+  end
+
+  it "should not override a given value" do
+    @pr.call(2)
+    @c.new('a'=>3).values.should == {:a=>3}
+    @c.new('a'=>nil).values.should == {:a=>nil}
+  end
+
+  it "should work correctly when subclassing" do
+    Class.new(@pr.call(2)).new.values.should == {:a=>2}
+  end
+
+  it "should contain the default values in default_values" do
+    @pr.call(2).default_values.should == {:a=>2}
+    @pr.call(nil).default_values.should == {}
+  end
+
+  it "should allow modifications of default values" do
+    @pr.call(2)
+    @c.default_values[:a] = 3
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should allow proc default values" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{3}
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should have procs that set default values set them to nil" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{nil}
+    @c.new.values.should == {:a => nil}
+  end
+
+  it "should work correctly on a model without a dataset" do
+    @pr.call(2)
+    c = Class.new(Sequel::Model(@db[:bar]))
+    c.plugin :defaults_setter
+    c.default_values.should == {:a=>2}
+  end
+end