sequel 3.22.0 → 3.23.0

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -0,0 +1,51 @@
+module Sequel
+  module Plugins
+    # Sequel's built in Serialization plugin doesn't check for modification
+    # of the serialized objects, because it requires an extra deserialization of a potentially
+    # very large object.  This plugin can detect changes in serialized values by
+    # checking whether the current deserialized value is the same as the original
+    # deserialized value.  This does require deserializing the value twice, but the
+    # original deserialized value is cached.
+    #
+    # == Example
+    #
+    #   require 'sequel'
+    #   require 'json'
+    #   class User < Sequel::Model
+    #     plugin :serialization, :json, :permissions
+    #     plugin :serialization_modification_detection
+    #   end
+    #   user = User.create(:permissions => {})
+    #   user.permissions[:global] = 'read-only'
+    #   user.save_changes
+    module SerializationModificationDetection
+      # Load the serialization plugin automatically.
+      def self.apply(model)
+        model.plugin :serialization
+      end
+      
+      module InstanceMethods
+        # Detect which serialized columns have changed.
+        def changed_columns
+          cc = super
+          deserialized_values.each{|c, v| cc << c if !cc.include?(c) && original_deserialized_value(c) != v} 
+          cc
+        end
+
+        private
+
+        # Clear the cache of original deserialized values after saving so that it doesn't
+        # show the column is modified after saving.
+        def after_save
+          super
+          @original_deserialized_values.clear if @original_deserialized_values
+        end
+
+        # Return the original deserialized value of the column, caching it to improve performance.
+        def original_deserialized_value(column)
+          (@original_deserialized_values ||= {})[column] ||= deserialize_value(column, self[column])
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/xml_serializer.rb

@@ -266,7 +266,7 @@ module Sequel
 
           name_proc = model.xml_serialize_name_proc(opts)
           x = model.xml_builder(opts)
-          x.send(name_proc[opts.fetch(:root_name, model.send(:underscore, model.name)).to_s]) do |x1|
+          x.send(name_proc[opts.fetch(:root_name, model.send(:underscore, model.name).gsub('/', '__')).to_s]) do |x1|
             cols.each do |c|
               attrs = {}
               if types

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 22
+  MINOR = 23
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/spec_helper.rb

@@ -10,6 +10,11 @@ begin
 rescue LoadError
 end
 
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
 class Sequel::Database
   def log_duration(duration, message)
     log_info(message)

data/spec/core/spec_helper.rb

@@ -5,6 +5,11 @@ unless Object.const_defined?('Sequel')
   require 'sequel/core'
 end
 
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
 class MockDataset < Sequel::Dataset
   def insert(*args)
     @db.execute insert_sql(*args)

data/spec/extensions/columns_introspection_spec.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+
+describe "Sequel::Dataset.introspect_all_columns" do
+  before do
+    @db = MODEL_DB
+    @ds = @db[:a]
+    class Sequel::Dataset
+      # Handle case where introspect_all_columns has already been called
+      alias columns columns_without_introspection unless instance_methods(false).map{|x| x.to_s}.include?('columns')
+    end
+    Sequel::Dataset.introspect_all_columns
+    @db.reset
+  end
+  after do
+    class Sequel::Dataset
+      alias columns columns_without_introspection
+    end
+  end
+
+  specify "should turn on column introspection by default" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+end
+
+describe "columns_introspection extension" do
+  before do
+    @db = MODEL_DB
+    @ds = @db[:a]
+    @ds.extend(Sequel::ColumnsIntrospection.dup) # dup to allow multiple places in class hierarchy
+    @db.reset
+  end
+
+  specify "should not issue a database query if the columns are already loaded" do
+    @ds.instance_variable_set(:@columns, [:x])
+    @ds.columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+  
+  specify "should handle plain symbols without a database query" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified symbols without a database query" do
+    @ds.select(:t__x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle aliased symbols without a database query" do
+    @ds.select(:x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified and aliased symbols without a database query" do
+    @ds.select(:t__x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::Identifiers " do
+    @ds.select(:x.identifier).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::QualifiedIdentifiers" do
+    @ds.select(:x.qualify(:t)).columns.should == [:x]
+    @ds.select(:x.identifier.qualify(:t)).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::AliasedExpressions" do
+    @ds.select(:x.as(:a)).columns.should == [:a]
+    @ds.select(:x.as(:a.identifier)).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should issue a database query if the wildcard is selected" do
+    @ds.columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should issue a database query if an unsupported type is used" do
+    @ds.select(1).columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should not have column introspection on by default" do
+    @db[:a].select(:x).columns
+    @db.sqls.length.should == 1
+  end
+end

data/spec/extensions/many_through_many_spec.rb

@@ -8,6 +8,7 @@ describe Sequel::Model, "many_through_many" do
       plugin :many_through_many
     end
     class ::Tag < Sequel::Model
+      columns :id, :h1, :h2
     end
     MODEL_DB.reset
     @c1 = Artist
@@ -111,6 +112,26 @@ describe Sequel::Model, "many_through_many" do
     n.tags.should == [@c2.load(:id=>1)]
   end
   
+  it "should allowing filtering by many_through_many associations" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE (albums_tags.tag_id = 1234)))'
+  end
+
+  it "should allowing filtering by many_through_many associations with a single through table" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id]]
+    @c1.filter(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists WHERE (albums_artists.album_id = 1234)))'
+  end
+
+  it "should allowing filtering by many_through_many associations with aliased tables" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :id, :id], [:albums_artists, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.id = albums_artists.album_id) INNER JOIN albums_artists AS albums_artists_1 ON (albums_artists_1.album_id = albums_artists_0.id) WHERE (albums_artists_1.tag_id = 1234)))'
+  end
+
+  it "should allowing filtering by many_through_many associations with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.filter(:tags=>@c2.load(:h1=>1234, :h2=>85)).sql.should == 'SELECT * FROM artists WHERE ((id, yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE ((albums_tags.g1 = 1234) AND (albums_tags.g2 = 85))))'
+  end
+
   it "should support a :conditions option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>{:a=>32}
     n = @c1.load(:id => 1234)

data/spec/extensions/serialization_modification_detection_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "serialization_modification_detection plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      columns :id, :h
+      plugin :serialization, :yaml, :h
+      plugin :serialization_modification_detection
+    end
+    @o1 = @c.new
+    @o2 = @c.load(:id=>1, :h=>"--- {}\n\n")
+    MODEL_DB.reset
+  end
+  
+  it "should not detect columns that haven't been changed" do
+    @o2.changed_columns.should == []
+    @o2.h.should == {}
+    @o2.h[1] = 2
+    @o2.h.clear
+    @o2.changed_columns.should == []
+  end
+  
+  it "should detect columns that have been changed" do
+    @o2.changed_columns.should == []
+    @o2.h.should == {}
+    @o2.h[1] = 2
+    @o2.changed_columns.should == [:h]
+  end
+  
+  it "should report correct changed_columns after saving" do
+    @o2.h[1] = 2
+    @o2.save_changes
+    @o2.changed_columns.should == []
+  end
+end

data/spec/extensions/spec_helper.rb

@@ -8,9 +8,11 @@ unless Sequel.const_defined?('Model')
   require 'sequel/model'
 end
 
-Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot')
+Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot columns_introspection')
 {:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}.each{|p, opts| Sequel::Model.plugin(p, *opts)}
 
+Sequel::Dataset.introspect_all_columns if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+
 def skip_warn(s)
   warn "Skipping test of #{s}" if ENV["SKIPPED_TEST_WARN"]
 end

data/spec/extensions/xml_serializer_spec.rb

@@ -36,6 +36,18 @@ describe "Sequel::Plugins::XmlSerializer" do
     Album.from_xml(@album.to_xml).should == @album
   end
 
+  it "should round trip successfully for namespaced models" do
+    module XmlSerializerTest
+      class Artist < Sequel::Model
+      plugin :xml_serializer
+      columns :id, :name
+      @db_schema = {:id=>{:type=>:integer}, :name=>{:type=>:string}}
+      end 
+    end
+    artist = XmlSerializerTest::Artist.load(:id=>2, :name=>'YJM')
+    XmlSerializerTest::Artist.from_xml(artist.to_xml).should == artist
+  end
+
   it "should round trip successfully with empty strings" do
     artist = Artist.load(:id=>2, :name=>'')
     Artist.from_xml(artist.to_xml).should == artist

data/spec/integration/associations_test.rb

@@ -22,6 +22,22 @@ shared_examples_for "regular and composite key associations" do
     @tag.albums.should == [@album]
   end
   
+  specify "should work correctly when filtering by associations" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    
+    @album.reload
+    @artist.reload
+    @tag.reload
+    
+    Artist.filter(:albums=>@album).all.should == [@artist]
+    Album.filter(:artist=>@artist).all.should == [@album]
+    Album.filter(:tags=>@tag).all.should == [@album]
+    Tag.filter(:albums=>@album).all.should == [@tag]
+    Album.filter(:artist=>@artist, :tags=>@tag).all.should == [@album]
+    @artist.albums_dataset.filter(:tags=>@tag).all.should == [@album]
+  end
+  
   specify "should have remove methods work" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
@@ -216,6 +232,48 @@ describe "Sequel::Model Simple Associations" do
     @tag.reload.albums.should == []
   end
   
+  specify "should handle dynamic callbacks for regular loading" do
+    @artist.add_album(@album)
+
+    @artist.albums.should == [@album]
+    @artist.albums(proc{|ds| ds.exclude(:id=>@album.id)}).should == []
+    @artist.albums(proc{|ds| ds.filter(:id=>@album.id)}).should == [@album]
+
+    @album.artist.should == @artist
+    @album.artist(proc{|ds| ds.exclude(:id=>@artist.id)}).should == nil
+    @album.artist(proc{|ds| ds.filter(:id=>@artist.id)}).should == @artist
+
+    if RUBY_VERSION >= '1.8.7'
+      @artist.albums{|ds| ds.exclude(:id=>@album.id)}.should == []
+      @artist.albums{|ds| ds.filter(:id=>@album.id)}.should == [@album]
+      @album.artist{|ds| ds.exclude(:id=>@artist.id)}.should == nil
+      @album.artist{|ds| ds.filter(:id=>@artist.id)}.should == @artist
+    end
+  end
+  
+  specify "should handle dynamic callbacks for eager loading via eager and eager_graph" do
+    @artist.add_album(@album)
+    @album.add_tag(@tag)
+    album2 = @artist.add_album(:name=>'Foo')
+    tag2 = album2.add_tag(:name=>'T2')
+
+    artist = Artist.eager(:albums=>:tags).all.first
+    artist.albums.should == [@album, album2]
+    artist.albums.map{|x| x.tags}.should == [[@tag], [tag2]]
+
+    artist = Artist.eager_graph(:albums=>:tags).all.first
+    artist.albums.should == [@album, album2]
+    artist.albums.map{|x| x.tags}.should == [[@tag], [tag2]]
+
+    artist = Artist.eager(:albums=>{proc{|ds| ds.where(:id=>album2.id)}=>:tags}).all.first
+    artist.albums.should == [album2]
+    artist.albums.first.tags.should == [tag2]
+
+    artist = Artist.eager_graph(:albums=>{proc{|ds| ds.where(:id=>album2.id)}=>:tags}).all.first
+    artist.albums.should == [album2]
+    artist.albums.first.tags.should == [tag2]
+  end
+  
   specify "should have remove method raise an error for one_to_many records if the object isn't already associated" do
     proc{@artist.remove_album(@album.id)}.should raise_error(Sequel::Error)
     proc{@artist.remove_album(@album)}.should raise_error(Sequel::Error)

data/spec/integration/plugin_test.rb

@@ -205,6 +205,11 @@ describe "Many Through Many Plugin" do
     Artist.filter(:artists__id=>2).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'A C'
     Artist.filter(:artists__id=>3).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'B C'
     Artist.filter(:artists__id=>4).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+
+    Artist.filter(:albums=>@album1).all.map{|a| a.name}.sort.should == %w'1 2'
+    Artist.filter(:albums=>@album2).all.map{|a| a.name}.sort.should == %w'3 4'
+    Artist.filter(:albums=>@album3).all.map{|a| a.name}.sort.should == %w'2 3'
+    Artist.filter(:albums=>@album4).all.map{|a| a.name}.sort.should == %w'1 4'
   end
 
   specify "should handle typical case with 3 join tables" do
@@ -223,6 +228,11 @@ describe "Many Through Many Plugin" do
     Artist.filter(:artists__id=>2).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 3'
     Artist.filter(:artists__id=>3).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'2 3 4'
     Artist.filter(:artists__id=>4).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 3 4'
+
+    Artist.filter(:related_artists=>@artist1).all.map{|a| a.name}.sort.should == %w'1 2 4'
+    Artist.filter(:related_artists=>@artist2).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    Artist.filter(:related_artists=>@artist3).all.map{|a| a.name}.sort.should == %w'2 3 4'
+    Artist.filter(:related_artists=>@artist4).all.map{|a| a.name}.sort.should == %w'1 3 4'
   end
 
   specify "should handle extreme case with 5 join tables" do
@@ -250,6 +260,11 @@ describe "Many Through Many Plugin" do
     Artist.filter(:artists__id=>2).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C D'
     Artist.filter(:artists__id=>3).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B D'
     Artist.filter(:artists__id=>4).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+
+    Artist.filter(:related_albums=>@album1).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    Artist.filter(:related_albums=>@album2).all.map{|a| a.name}.sort.should == %w'1 2 3 4'
+    Artist.filter(:related_albums=>@album3).all.map{|a| a.name}.sort.should == %w'1 2'
+    Artist.filter(:related_albums=>@album4).all.map{|a| a.name}.sort.should == %w'2 3 4'
   end
 end
 

data/spec/integration/spec_helper.rb

@@ -9,6 +9,11 @@ begin
 rescue LoadError
 end
 
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
 Sequel::Model.use_transactions = false
 
 $sqls = []

data/spec/model/associations_spec.rb

@@ -357,6 +357,28 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"]
   end
   
+  it "should use a callback if given one as the argument" do
+    @c2.many_to_one :parent, :class => @c2
+
+    d = @c2.create(:id => 1)
+    MODEL_DB.reset
+    d.parent_id = 234
+    d.associations[:parent] = 42
+    d.parent(proc{|ds| ds.filter{name > 'M'}}).should_not == 42 
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 234) AND (name > 'M')) LIMIT 1"]
+  end
+  
+  it "should use a block given to the association method as a callback on ruby 1.8.7+" do
+    @c2.many_to_one :parent, :class => @c2
+
+    d = @c2.create(:id => 1)
+    MODEL_DB.reset
+    d.parent_id = 234
+    d.associations[:parent] = 42
+    d.parent{|ds| ds.filter{name > 'M'}}.should_not == 42 
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 234) AND (name > 'M')) LIMIT 1"]
+  end if RUBY_VERSION >= '1.8.7'
+  
   it "should have the setter add to the reciprocal one_to_many cached association list if it exists" do
     @c2.many_to_one :parent, :class => @c2
     @c2.one_to_many :children, :class => @c2, :key=>:parent_id
@@ -1149,6 +1171,16 @@ describe Sequel::Model, "one_to_many" do
     v.model.should == Historical::Value
   end
 
+  it "should use a callback if given one as the argument" do
+    @c2.one_to_many :attributes, :class => @c1, :key => :nodeid
+    
+    d = @c2.create(:id => 1234)
+    MODEL_DB.reset
+    d.associations[:attributes] = []
+    d.attributes(proc{|ds| ds.filter{name > 'M'}}).should_not == []
+    MODEL_DB.sqls.should == ["SELECT * FROM attributes WHERE ((attributes.nodeid = 1234) AND (name > 'M'))"]
+  end
+  
   it "should use explicit key if given" do
     @c2.one_to_many :attributes, :class => @c1, :key => :nodeid
     
@@ -2724,3 +2756,88 @@ describe Sequel::Model, " association reflection methods" do
     c.instance_methods.map{|x| x.to_s}.should include('parent')
   end
 end
+
+describe "Filtering by associations" do
+  before do
+    @Album = Class.new(Sequel::Model(:albums))
+    artist = @Artist = Class.new(Sequel::Model(:artists))
+    tag = @Tag = Class.new(Sequel::Model(:tags))
+    track = @Track = Class.new(Sequel::Model(:tracks))
+    album_info = @AlbumInfo = Class.new(Sequel::Model(:album_infos))
+    @Artist.columns :id, :id1, :id2
+    @Tag.columns :id, :tid1, :tid2
+    @Track.columns :id, :album_id, :album_id1, :album_id2
+    @AlbumInfo.columns :id, :album_id, :album_id1, :album_id2
+    @Album.class_eval do
+      columns :id, :id1, :id2, :artist_id, :artist_id1, :artist_id2
+      many_to_one :artist, :class=>artist
+      one_to_many :tracks, :class=>track, :key=>:album_id
+      one_to_one :album_info, :class=>album_info, :key=>:album_id
+      many_to_many :tags, :class=>tag, :left_key=>:album_id, :join_table=>:albums_tags
+
+      many_to_one :cartist, :class=>artist, :key=>[:artist_id1, :artist_id2], :primary_key=>[:id1, :id2]
+      one_to_many :ctracks, :class=>track, :key=>[:album_id1, :album_id2], :primary_key=>[:id1, :id2]
+      one_to_one :calbum_info, :class=>album_info, :key=>[:album_id1, :album_id2], :primary_key=>[:id1, :id2]
+      many_to_many :ctags, :class=>tag, :left_key=>[:album_id1, :album_id2], :left_primary_key=>[:id1, :id2], :right_key=>[:tag_id1, :tag_id2], :right_primary_key=>[:tid1, :tid2], :join_table=>:albums_tags
+    end
+  end
+
+  it "should be able to filter on many_to_one associations" do
+    @Album.filter(:artist=>@Artist.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (artist_id = 3)'
+  end
+
+  it "should be able to filter on one_to_many associations" do
+    @Album.filter(:tracks=>@Track.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE (id = 3)'
+  end
+
+  it "should be able to filter on one_to_one associations" do
+    @Album.filter(:album_info=>@AlbumInfo.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE (id = 3)'
+  end
+
+  it "should be able to filter on many_to_many associations" do
+    @Album.filter(:tags=>@Tag.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM albums_tags WHERE (tag_id = 3)))'
+  end
+
+  it "should be able to filter on many_to_one associations with composite keys" do
+    @Album.filter(:cartist=>@Artist.load(:id1=>3, :id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((artist_id1 = 3) AND (artist_id2 = 4))'
+  end
+
+  it "should be able to filter on one_to_many associations with composite keys" do
+    @Album.filter(:ctracks=>@Track.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 = 3) AND (id2 = 4))'
+  end
+
+  it "should be able to filter on one_to_one associations with composite keys" do
+    @Album.filter(:calbum_info=>@AlbumInfo.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 = 3) AND (id2 = 4))' 
+  end
+
+  it "should be able to filter on many_to_many associations with composite keys" do
+    @Album.filter(:ctags=>@Tag.load(:tid1=>3, :tid2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE ((tag_id1 = 3) AND (tag_id2 = 4))))'
+  end
+
+  it "should work inside a complex filter" do
+    artist = @Artist.load(:id=>3)
+    @Album.filter{foo & {:artist=>artist}}.sql.should == 'SELECT * FROM albums WHERE (foo AND (artist_id = 3))'
+    track = @Track.load(:album_id=>4)
+    @Album.filter{foo & [[:artist, artist], [:tracks, track]]}.sql.should == 'SELECT * FROM albums WHERE (foo AND (artist_id = 3) AND (id = 4))'
+  end
+
+  it "should raise for an invalid association name" do
+    proc{@Album.filter(:foo=>@Artist.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise for an invalid association type" do
+    @Album.many_to_many :iatags, :clone=>:tags
+    @Album.association_reflection(:iatags)[:type] = :foo
+    proc{@Album.filter(:mtmtags=>@Tag.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise for an invalid associated object class " do
+    proc{@Album.filter(:tags=>@Artist.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should work correctly in subclasses" do
+    c = Class.new(@Album)
+    c.many_to_one :sartist, :class=>@Artist
+    c.filter(:sartist=>@Artist.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (sartist_id = 3)'
+  end
+end