sequel 4.33.0 → 4.34.0

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -47,7 +47,8 @@ module Sequel
           if db_schema
             h = {}
             db_schema.each do |k, v|
-              h[k] = v[:ruby_default] if (v[:ruby_default] || !v[:default]) && !v[:primary_key]
+              default = v[:ruby_default]
+              h[k] = default if (default || !v[:default]) && !v[:primary_key] && !default.is_a?(Sequel::SQL::Expression)
             end
             @prepared_statements_column_defaults = h
           end

data/lib/sequel/plugins/update_or_create.rb

@@ -7,7 +7,7 @@ module Sequel
     # The first method is update_or_create, which updates an object if it
     # exists in the database, or creates the object if it does not.
     #
-    # You can call create_or_update with a block:
+    # You can call update_or_create with a block:
     #
     #   Album.update_or_create(:name=>'Hello') do |album|
     #     album.num_copies_sold = 1000

data/lib/sequel/plugins/validation_helpers.rb

@@ -87,6 +87,7 @@ module Sequel
         :min_length=>{:message=>lambda{|min| "is shorter than #{min} characters"}},
         :not_null=>{:message=>lambda{"is not present"}},
         :numeric=>{:message=>lambda{"is not a number"}},
+        :operator=>{:message=>lambda{|operator, rhs| "is not #{operator} #{rhs}"}},
         :type=>{:message=>lambda{|klass| klass.is_a?(Array) ? "is not a valid #{klass.join(" or ").downcase}" : "is not a valid #{klass.to_s.downcase}"}},
         :presence=>{:message=>lambda{"is not present"}},
         :unique=>{:message=>lambda{'is already taken'}}
@@ -155,6 +156,12 @@ module Sequel
           end
         end
 
+        # Check attribute value(s) against a specified value and operation, e.g.
+        # validates_operator(:>, 3, :value) validates that value > 3.
+        def validates_operator(operator, rhs, atts, opts=OPTS)
+          validatable_attributes_for_type(:operator, atts, opts){|a,v,m| validation_error_message(m, operator, rhs) unless v.send(operator, rhs)}
+        end
+
         # Validates for all of the model columns (or just the given columns)
         # that the column value is an instance of the expected class based on
         # the column's schema type.

data/lib/sequel/version.rb

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

data/spec/adapters/postgres_spec.rb

@@ -3094,6 +3094,20 @@ describe 'PostgreSQL inet/cidr types' do
   end
 end
 
+describe 'PostgreSQL custom range types' do
+  after do
+    @db.run "DROP TYPE timerange";
+  end
+
+  it "should allow registration and use" do
+    @db = DB
+    @db.run "CREATE TYPE timerange AS range (subtype = time)"
+    @db.register_range_type('timerange')
+    r = Sequel::SQLTime.create(10, 11, 12)..Sequel::SQLTime.create(11, 12, 13)
+    @db.get(Sequel.pg_range(r, :timerange)).to_range.must_equal r
+  end
+end if DB.server_version >= 90200 && DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
+
 describe 'PostgreSQL range types' do
   before(:all) do
     @db = DB

data/spec/adapters/spec_helper.rb

@@ -15,6 +15,7 @@ begin
 rescue LoadError
 end
 
+Sequel::Database.extension :duplicate_column_handler if ENV['SEQUEL_DUPLICATE_COLUMN_HANDLER']
 Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
 Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
 Sequel.cache_anonymous_models = false
@@ -41,3 +42,8 @@ unless defined?(DB)
   env_var = ENV.has_key?(env_var) ? env_var : 'SEQUEL_INTEGRATION_URL'
   DB = Sequel.connect(ENV[env_var])
 end
+
+if dch = ENV['SEQUEL_DUPLICATE_COLUMNS_HANDLER']
+  DB.extension :duplicate_columns_handler
+  DB.opts[:on_duplicate_columns] = dch.to_sym unless dch.empty?
+end

data/spec/core/connection_pool_spec.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 CONNECTION_POOL_DEFAULTS = {:pool_timeout=>5, :pool_sleep_time=>0.001, :max_connections=>4}
+require 'sequel/connection_pool/sharded_threaded'
 
 mock_db = lambda do |*a, &b|
   db = Sequel.mock
@@ -296,10 +297,14 @@ ThreadedConnectionPoolSpecs = shared_description do
 
   it "should raise a PoolTimeout error if a connection couldn't be acquired before timeout" do
     q, q1 = Queue.new, Queue.new
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>1, :pool_timeout=>0))
+    db = mock_db.call(&@icpp)
+    db.opts[:name] = 'testing'
+    pool = Sequel::ConnectionPool.get_pool(db, @cp_opts.merge(:max_connections=>1, :pool_timeout=>0))
     t = Thread.new{pool.hold{|c| q1.push nil; q.pop}}
     q1.pop
-    proc{pool.hold{|c|}}.must_raise(Sequel::PoolTimeout)
+    e = proc{pool.hold{|c|}}.must_raise(Sequel::PoolTimeout)
+    e.message.must_include "name: testing"
+    e.message.must_include "server: default" if pool.is_a?(Sequel::ShardedThreadedConnectionPool)
     q.push nil
     t.join
   end
@@ -492,7 +497,14 @@ describe "A connection pool with multiple servers" do
     @pool.send(:preconnect)
     i = 0
     @pool.all_connections{|c1| i+=1}
-    i.must_equal @pool.max_size * 2
+    i.must_equal(@pool.max_size * 2)
+  end
+
+  it "should support preconnect method that immediately creates the maximum number of connections concurrently" do
+    @pool.send(:preconnect, true)
+    i = 0
+    @pool.all_connections{|c1| i+=1}
+    i.must_equal(@pool.max_size * 2)
   end
 
   it "#all_connections should return connections for all servers" do
@@ -769,6 +781,13 @@ describe "A single threaded pool with multiple servers" do
     i.must_equal 2
   end
 
+  it "should support preconnect method that immediately creates the maximum number of connections, ignoring concurrent param" do
+    @pool.send(:preconnect, true)
+    i = 0
+    @pool.all_connections{|c1| i+=1}
+    i.must_equal 2
+  end
+
   it "#all_connections should return connections for all servers" do
     @pool.hold{}
     @pool.all_connections{|c1| c1.must_equal :default}
@@ -912,6 +931,14 @@ AllConnectionPoolClassesSpecs = shared_description do
     i.must_equal p.max_size
   end
 
+  it "should support preconnect method that immediately creates the maximum number of connections concurrently" do
+    p = @class.new(mock_db.call{123}, {})
+    p.send(:preconnect, true)
+    i = 0
+    p.all_connections{|c1| i+=1}
+    i.must_equal p.max_size
+  end
+
   it "should be able to modify after_connect proc after the pool is created" do
     a = []
     p = @class.new(mock_db.call{123}, {})

data/spec/core/database_spec.rb

@@ -32,6 +32,8 @@ describe "A new Database" do
     end
     db = c.new(1 => 2, :logger => 3, :preconnect=>true)
     db.pool.size.must_equal db.pool.max_size
+    db = c.new(1 => 2, :logger => 3, :preconnect=>:concurrently)
+    db.pool.size.must_equal db.pool.max_size
   end
   
   it "should handle the default string column size" do

data/spec/core/dataset_spec.rb

@@ -1761,6 +1761,10 @@ describe "Dataset#to_hash" do
     @d.to_hash(:b).must_equal(2 => {:a => 1, :b => 2}, 4 => {:a => 3, :b => 4}, 6 => {:a => 5, :b => 6})
   end
 
+  it "should accept an optional :hash parameter into which entries can be merged" do
+    @d.to_hash(:a, :b, :hash => (tmp = {})).must_be_same_as(tmp)
+  end
+
   it "should support using an array of columns as either the key or the value" do
     @d.to_hash([:a, :b], :b).must_equal([1, 2] => 2, [3, 4] => 4, [5, 6] => 6)
     @d.to_hash(:b, [:a, :b]).must_equal(2 => [1, 2], 4 => [3, 4], 6 => [5, 6])
@@ -1818,6 +1822,10 @@ describe "Dataset#to_hash_groups" do
     @d.to_hash_groups([:a, :b]).must_equal([1, 2] => [{:a => 1, :b => 2}], [3, 4] => [{:a => 3, :b => 4}], [1, 6] => [{:a => 1, :b => 6}], [7, 4] => [{:a => 7, :b => 4}])
   end
 
+  it "should accept an optional :hash parameter into which entries can be merged" do
+    @d.to_hash_groups(:a, :b, :hash => (tmp = {})).must_be_same_as(tmp)
+  end
+
   it "should not call the row_proc if two arguments are given" do
     @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
     @d.to_hash_groups(:a, :b).must_equal(1 => [2, 6], 3 => [4], 7 => [4])

data/spec/extensions/dataset_associations_spec.rb

@@ -90,6 +90,38 @@ describe "Sequel::Plugins::DatasetAssociations" do
     ds.sql.must_equal "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) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
   end
 
+  it "should work for many_to_many associations with :dataset_association_join=>true" do
+    @Album.many_to_many :tags, :clone=>:tags, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, :albums_tags__foo]
+    ds = @Album.tags
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.*, albums_tags.foo FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id) IN (SELECT albums.id FROM albums))))"
+  end
+
+  it "should work for one_through_one associations with :dataset_association_join=>true" do
+    @Album.one_through_one :first_tag, :clone=>:first_tag, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, :albums_tags__foo]
+    ds = @Album.first_tags
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.*, albums_tags.foo FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id) IN (SELECT albums.id FROM albums))))"
+  end
+
+  it "should work for many_through_many associations with :dataset_association_join=>true" do
+    @Artist.many_through_many :tags, :clone=>:tags, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, :albums_tags__foo]
+    ds = @Artist.tags
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.*, albums_tags.foo FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) 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) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
+  end
+
+  it "should work for one_through_many associations with :dataset_association_join=>true" do
+    @Artist.one_through_many :otag, :clone=>:otag, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, :albums_tags__foo]
+    ds = @Artist.otags
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.*, albums_tags.foo FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) 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) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
+  end
+
   it "should work for pg_array_to_many associations" do
     ds = @Artist.artist_tags
     ds.must_be_kind_of(Sequel::Dataset)

data/spec/extensions/duplicate_columns_handler_spec.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+mod = shared_description do
+  it "should take action depending on :on_duplicate_columns if 2 or more columns have the same name" do
+    check(nil, @cols)
+    @warned.must_equal nil
+
+    check(:ignore, @cols)
+    @warned.must_equal nil
+
+    check(:warn, @cols)
+    @warned.must_equal("One or more duplicate columns present in #{@cols.inspect}")
+
+    proc{check(:raise, @cols)}.must_raise(Sequel::DuplicateColumnError)
+
+    cols = nil
+    check(proc{|cs| cols = cs; nil}, @cols)
+    @warned.must_equal nil
+    cols.must_equal @cols
+
+    cols = nil
+    check(proc{|cs| cols = cs; :ignore}, @cols)
+    @warned.must_equal nil
+    cols.must_equal @cols
+
+    cols = nil
+    proc{check(proc{|cs| cols = cs; :raise}, @cols)}.must_raise(Sequel::DuplicateColumnError)
+    cols.must_equal @cols
+
+    cols = nil
+    check(proc{|cs| cols = cs; :warn}, @cols)
+    @warned.must_equal("One or more duplicate columns present in #{@cols.inspect}")
+    cols.must_equal @cols
+
+    check(:raise, nil)
+    @warned.must_equal nil
+  end
+
+  it "should not raise error or warning if no columns have the same name" do
+    [nil, :ignore, :raise, :warn, proc{|cs| :raise}].each do |handler|
+      check(handler, @cols.uniq)
+      @warned.must_equal nil
+    end
+  end
+end
+
+describe "Sequel::DuplicateColumnsHandler Database configuration" do
+  before do
+    @db = Sequel.mock
+    @db.extension(:duplicate_columns_handler)
+    @ds = @db[:things]
+    @cols = [:id, :name, :id]
+    @warned = nil
+    set_warned = @set_warned = proc{|m| @warned = m}
+    @ds.meta_def(:warn) do |message|
+      set_warned.call(message)
+    end
+  end
+
+  def check(handler, cols)
+    @db.opts[:on_duplicate_columns] = handler
+    @set_warned.call(nil)
+    @ds.send(:columns=, cols)
+  end
+
+  include mod
+end
+
+describe "Sequel::DuplicateColumnsHandler Dataset configuration" do
+  before do
+    @ds = Sequel.mock[:things].extension!(:duplicate_columns_handler)
+    @cols = [:id, :name, :id]
+    @warned = nil
+    set_warned = @set_warned = proc{|m| @warned = m}
+    @ds.meta_def(:warn) do |message|
+      set_warned.call(message)
+    end
+  end
+
+  def check(handler, cols)
+    @set_warned.call(nil)
+    @ds.on_duplicate_columns(handler).send(:columns=, cols)
+  end
+
+  include mod
+
+  it "should use handlers passed as blocks to on_duplicate_columns" do
+    proc{@ds.on_duplicate_columns{:raise}.send(:columns=, @cols)}.must_raise(Sequel::DuplicateColumnError)
+  end
+
+  it "should raise an error if not providing either an argument or block to on_duplicate_columns" do
+    proc{@ds.on_duplicate_columns}.must_raise(Sequel::Error)
+  end
+
+  it "should raise an error if providing both an argument and block to on_duplicate_columns" do
+    proc{@ds.on_duplicate_columns(:raise){:raise}}.must_raise(Sequel::Error)
+  end
+
+  it "should warn by defaul if there is no database or dataset handler" do
+    @ds.send(:columns=, @cols)
+    @warned.must_equal("One or more duplicate columns present in #{@cols.inspect}")
+  end
+
+  it "should fallback to database setting if there is no dataset-level handler" do
+    @ds.db.opts[:on_duplicate_columns] = :raise
+    proc{@ds.send(:columns=, @cols)}.must_raise(Sequel::DuplicateColumnError)
+    check(:ignore, @cols)
+    @warned.must_equal nil
+  end
+end

data/spec/extensions/pg_range_spec.rb

@@ -166,6 +166,46 @@ describe "pg_range extension" do
     Sequel::Postgres::PG_TYPES[331].call('[1,3)').must_be_kind_of(@R)
   end
 
+  it "should support registering custom range types on a per-Database basis" do
+    @db.register_range_type('banana', :oid=>7865){|s| s}
+    @db.typecast_value(:banana, '[1,2]').class.must_equal(Sequel::Postgres::PGRange)
+    @db.fetch = [{:name=>'id', :db_type=>'banana'}]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:banana]
+    @db.conversion_procs.must_include(7865)
+    @db.respond_to?(:typecast_value_banana, true).must_equal true
+
+    db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    db.extend_datasets(Module.new{def supports_timestamp_timezones?; false; end; def supports_timestamp_usecs?; false; end})
+    db.extension(:pg_range)
+    db.fetch = [{:name=>'id', :db_type=>'banana'}]
+    db.schema(:items).map{|e| e[1][:type]}.must_equal [nil]
+    db.conversion_procs.wont_include(7865)
+    db.respond_to?(:typecast_value_banana, true).must_equal false
+  end
+
+  it "should automatically look up the range and subtype oids when registering per-Database types" do
+    @db.fetch = [[{:rngsubtype=>21, :rngtypid=>7866}], [{:name=>'id', :db_type=>'banana'}]]
+    @db.register_range_type('banana', :subtype_typecast=>:integer)
+    @db.sqls.must_equal ["SELECT rngtypid, rngsubtype FROM pg_range INNER JOIN pg_type ON (pg_type.oid = pg_range.rngtypid) WHERE (typname = 'banana') LIMIT 1"]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:banana]
+    @db.conversion_procs[7866].call("[1,3)").must_be :==, (1...3)
+    @db.typecast_value(:banana, '[1,2]').must_be :==, (1..2)
+  end
+
+  it "should not automatically look up oids if given both subtype and range oids" do
+    @db.register_range_type('banana', :oid=>7866, :subtype_oid=>21)
+    @db.sqls.must_equal []
+    @db.conversion_procs[7866].call("[1,3)").must_be :==, (1...3)
+    @db.typecast_value(:banana, '[1,2]').must_be :==, (1..2)
+  end
+
+  it "should not automatically look up oids if given range oid and block" do
+    @db.register_range_type('banana', :oid=>7866){|s| s.to_i}
+    @db.sqls.must_equal []
+    @db.conversion_procs[7866].call("[1,3)").must_be :==, (1...3)
+    @db.typecast_value(:banana, '[1,2]').must_be :==, (1..2)
+  end
+
   it "should return correct results for Database#schema_type_class" do
     @db.schema_type_class(:int4range).must_equal Sequel::Postgres::PGRange
     @db.schema_type_class(:integer).must_equal Integer

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -17,7 +17,7 @@ describe "prepared_statements_safe plugin" do
 
   it "should set default values correctly" do
     @c.prepared_statements_column_defaults.must_equal(:name=>nil, :i=>nil)
-    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}, :bar=>{:ruby_default=>Sequel::CURRENT_TIMESTAMP}})
     Class.new(@c).prepared_statements_column_defaults.must_equal(:name=>'foo')
   end
 

data/spec/extensions/validation_helpers_spec.rb

@@ -538,4 +538,15 @@ describe "Sequel::Plugins::ValidationHelpers" do
     m.wont_be :valid?
     DB.sqls.must_equal []
   end
+
+  it "should support validates_operator" do
+    @c.set_validations{validates_operator(:>, 3, :value)}
+    @m.value = 1
+    @m.wont_be :valid?
+    @m.errors.full_messages.must_equal ['value is not > 3']
+    @m.value = 3
+    @m.wont_be :valid?
+    @m.value = 4
+    @m.must_be :valid?
+  end
 end 

data/spec/integration/associations_test.rb

@@ -393,15 +393,15 @@ end
 
 FilterByAssociations = shared_description do
   it "should handle association inner joins" do
-    @Artist.association_join(:albums).all.must_equal []
-    @Artist.association_join(:first_album).all.must_equal []
-    @Album.association_join(:artist).all.must_equal []
-    @Album.association_join(:tags).all.must_equal []
-    @Album.association_join(:alias_tags).all.must_equal []
-    @Tag.association_join(:albums).all.must_equal []
+    @Artist.association_join(:albums).select(Sequel.qualify(@Artist.first_source, @Artist.columns.first)).all.must_equal []
+    @Artist.association_join(:first_album).select(Sequel.qualify(@Artist.first_source, @Artist.columns.first)).all.must_equal []
+    @Album.association_join(:artist).select(Sequel.qualify(@Album.first_source, @Album.columns.first)).all.must_equal []
+    @Album.association_join(:tags).select(Sequel.qualify(@Album.first_source, @Album.columns.first)).all.must_equal []
+    @Album.association_join(:alias_tags).select(Sequel.qualify(@Album.first_source, @Album.columns.first)).all.must_equal []
+    @Tag.association_join(:albums).select(Sequel.qualify(@Tag.first_source, @Tag.columns.first)).all.must_equal []
     unless @no_many_through_many
-      @Artist.association_join(:tags).all.must_equal []
-      @Artist.association_join(:first_tag).all.must_equal []
+      @Artist.association_join(:tags).select(Sequel.qualify(@Artist.first_source, @Artist.columns.first)).all.must_equal []
+      @Artist.association_join(:first_tag).select(Sequel.qualify(@Artist.first_source, @Artist.columns.first)).all.must_equal []
     end
 
     @album.update(:artist => @artist)
@@ -2067,6 +2067,20 @@ describe "Sequel::Model Simple Associations" do
     proc{@artist.remove_album(@album.id)}.must_raise(Sequel::Error)
     proc{@artist.remove_album(@album)}.must_raise(Sequel::Error)
   end
+
+  it "should handle dataset associations with :dataset_associations_join options" do
+    Album.many_to_many :tags, :right_key=>:tag_id, :select=>[Sequel.expr(:tags).*, :albums_tags__tag_id___atid], :dataset_associations_join=>true
+    Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[Sequel.expr(:tags).*, :albums_tags__tag_id___atid, :albums__artist_id___aid], :dataset_associations_join=>true
+
+    Album.tags.order(:tags__name).first.must_equal nil
+    Artist.tags.order(:tags__name).first.must_equal nil
+
+    @album.add_tag(@tag)
+    @artist.add_album(@album)
+
+    Album.tags.order(:tags__name).first.must_equal Tag.load(:id=>@tag.id, :name=>"T", :atid=>@tag.id)
+    Artist.tags.order(:tags__name).first.must_equal Tag.load(:id=>@tag.id, :name=>"T", :atid=>@tag.id, :aid=>@artist.id)
+  end
 end
 
 describe "Sequel::Model Composite Key Associations" do