sequel 3.36.1 → 3.37.0

data/spec/adapters/sqlite_spec.rb

@@ -1,7 +1,13 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 unless defined?(SQLITE_DB)
-  SQLITE_URL = 'sqlite:/' unless defined? SQLITE_URL
+  unless defined? SQLITE_URL
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+      SQLITE_URL = 'jdbc:sqlite::memory:'
+    else
+      SQLITE_URL = 'sqlite:/'
+    end
+  end
   SQLITE_DB = Sequel.connect(ENV['SEQUEL_SQLITE_SPEC_DB']||SQLITE_URL)
 end
 INTEGRATION_DB = SQLITE_DB unless defined?(INTEGRATION_DB)
@@ -49,6 +55,15 @@ describe "An SQLite database" do
     @db.get(Sequel.like('a', 'A')).to_s.should == '0'
   end
   
+  specify "should support casting to Date by using the date function" do
+    @db.get('2012-10-20 11:12:13'.cast(Date)).should == '2012-10-20'
+  end
+  
+  specify "should support casting to Time or DateTime by using the datetime function" do
+    @db.get('2012-10-20'.cast(Time)).should == '2012-10-20 00:00:00'
+    @db.get('2012-10-20'.cast(DateTime)).should == '2012-10-20 00:00:00'
+  end
+  
   specify "should provide the SQLite version as an integer" do
     @db.sqlite_version.should be_a_kind_of(Integer)
   end

data/spec/core/database_spec.rb

@@ -1985,8 +1985,9 @@ end
 describe "Database#schema_autoincrementing_primary_key?" do
   specify "should indicate whether the parsed schema row indicates a primary key" do
     m = Sequel::Database.new.method(:schema_autoincrementing_primary_key?)
-    m.call(:primary_key=>true).should == true
-    m.call(:primary_key=>false).should == false
+    m.call(:primary_key=>true, :db_type=>'integer').should == true
+    m.call(:primary_key=>true, :db_type=>'varchar(255)').should == false
+    m.call(:primary_key=>false, :db_type=>'integer').should == false
   end
 end
 
@@ -2124,3 +2125,61 @@ describe "Database#column_schema_to_ruby_default" do
     p["((-12.1))", :decimal].should == BigDecimal.new('-12.1')
   end
 end
+
+describe "Database extensions" do
+  before(:all) do
+    class << Sequel
+      alias _extension extension
+      def extension(*)
+      end
+    end
+  end
+  after(:all) do
+    class << Sequel
+      alias extension _extension
+    end
+  end
+  before do
+    @db = Sequel.mock
+  end
+
+  specify "should be able to register an extension with a module Database#extension extend the module" do
+    Sequel::Database.register_extension(:foo, Module.new{def a; 1; end})
+    @db.extension(:foo).a.should == 1
+  end
+
+  specify "should be able to register an extension with a block and Database#extension call the block" do
+    @db.quote_identifiers = false
+    Sequel::Database.register_extension(:foo){|db| db.quote_identifiers = true}
+    @db.extension(:foo).quote_identifiers?.should be_true
+  end
+
+  specify "should be able to register an extension with a callable and Database#extension call the callable" do
+    @db.quote_identifiers = false
+    Sequel::Database.register_extension(:foo, proc{|db| db.quote_identifiers = true})
+    @db.extension(:foo).quote_identifiers?.should be_true
+  end
+
+  specify "should be able to load multiple extensions in the same call" do
+    @db.quote_identifiers = false
+    @db.identifier_input_method = :downcase
+    Sequel::Database.register_extension(:foo, proc{|db| db.quote_identifiers = true})
+    Sequel::Database.register_extension(:bar, proc{|db| db.identifier_input_method = nil})
+    @db.extension(:foo, :bar)
+    @db.quote_identifiers?.should be_true
+    @db.identifier_input_method.should be_nil
+  end
+
+  specify "should return the receiver" do
+    Sequel::Database.register_extension(:foo, Module.new{def a; 1; end})
+    @db.extension(:foo).should equal(@db)
+  end
+
+  specify "should raise an Error if registering with both a module and a block" do
+    proc{Sequel::Database.register_extension(:foo, Module.new){}}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an Error if attempting to load an incompatible extension" do
+    proc{@db.extension(:foo2)}.should raise_error(Sequel::Error)
+  end
+end

data/spec/core/dataset_spec.rb

@@ -2152,6 +2152,14 @@ describe "Dataset#join_table" do
     @d.from('stats').join('players', {:id => :player_id}, :implicit_qualifier=>:p).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" ON ("players"."id" = "p"."player_id")'
   end
   
+  specify "should not qualify if :qualify=>false option is given" do
+    @d.from('stats').join(:players, {:id => :player_id}, :qualify=>false).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" ON ("id" = "player_id")'
+  end
+  
+  specify "should do deep qualification if :qualify=>:deep option is given" do
+    @d.from('stats').join(:players, {Sequel.function(:f, :id) => Sequel.subscript(:player_id, 0)}, :qualify=>:deep).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" ON (f("players"."id") = "stats"."player_id"[0])'
+  end
+  
   specify "should allow for arbitrary conditions in the JOIN clause" do
     @d.join_table(:left_outer, :categories, :status => 0).sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."status" = 0)'
     @d.join_table(:left_outer, :categories, :categorizable_type => "Post").sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."categorizable_type" = \'Post\')'
@@ -4306,3 +4314,87 @@ describe "Dataset feature defaults" do
     Sequel::Database.new.dataset.send(:offset_returns_row_number_column?).should be_false
   end
 end
+
+describe "Dataset extensions" do
+  before(:all) do
+    class << Sequel
+      alias _extension extension
+      def extension(*)
+      end
+    end
+  end
+  after(:all) do
+    class << Sequel
+      alias extension _extension
+    end
+  end
+  before do
+    @ds = Sequel::Dataset.new(nil)
+  end
+
+  specify "should be able to register an extension with a module Database#extension extend the module" do
+    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
+    @ds.extension(:foo).a.should == 1
+  end
+
+  specify "should be able to register an extension with a block and Database#extension call the block" do
+    @ds.quote_identifiers = false
+    Sequel::Dataset.register_extension(:foo){|db| db.quote_identifiers = true}
+    @ds.extension(:foo).quote_identifiers?.should be_true
+  end
+
+  specify "should be able to register an extension with a callable and Database#extension call the callable" do
+    @ds.quote_identifiers = false
+    Sequel::Dataset.register_extension(:foo, proc{|db| db.quote_identifiers = true})
+    @ds.extension(:foo).quote_identifiers?.should be_true
+  end
+
+  specify "should be able to load multiple extensions in the same call" do
+    @ds.quote_identifiers = false
+    @ds.identifier_input_method = :downcase
+    Sequel::Dataset.register_extension(:foo, proc{|ds| ds.quote_identifiers = true})
+    Sequel::Dataset.register_extension(:bar, proc{|ds| ds.identifier_input_method = nil})
+    ds = @ds.extension(:foo, :bar)
+    ds.quote_identifiers?.should be_true
+    ds.identifier_input_method.should be_nil
+  end
+
+  specify "should have #extension not modify the receiver" do
+    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
+    @ds.extension(:foo)
+    proc{@ds.a}.should raise_error(NoMethodError)
+  end
+
+  specify "should have #extension not return a cloned dataset" do
+    @ds.extend(Module.new{def b; 2; end})
+    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
+    v = @ds.extension(:foo)
+    v.should_not equal(@ds)
+    v.should be_a_kind_of(Sequel::Dataset)
+    v.b.should == 2
+  end
+
+  specify "should have #extension! modify the receiver" do
+    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
+    @ds.extension!(:foo)
+    @ds.a.should == 1
+  end
+
+  specify "should have #extension! return the receiver" do
+    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
+    @ds.extension!(:foo).should equal(@ds)
+  end
+
+  specify "should register a Database extension for modifying all datasets when registering with a module" do
+    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
+    Sequel.mock.extension(:foo).dataset.a.should == 1
+  end
+
+  specify "should raise an Error if registering with both a module and a block" do
+    proc{Sequel::Dataset.register_extension(:foo, Module.new){}}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an Error if attempting to load an incompatible extension" do
+    proc{@ds.extension(:foo2)}.should raise_error(Sequel::Error)
+  end
+end

data/spec/core/expression_filters_spec.rb

@@ -1042,3 +1042,15 @@ describe Sequel::SQL::Subscript do
     @ds.literal(s).should == 'a[1][2]'
   end
 end
+
+describe "Sequel.recursive_map" do
+  specify "should recursively convert an array using a callable" do
+    Sequel.recursive_map(['1'], proc{|s| s.to_i}).should == [1]
+    Sequel.recursive_map([['1']], proc{|s| s.to_i}).should == [[1]]
+  end
+
+  specify "should not call callable if value is nil" do
+    Sequel.recursive_map([nil], proc{|s| s.to_i}).should == [nil]
+    Sequel.recursive_map([[nil]], proc{|s| s.to_i}).should == [[nil]]
+  end
+end

data/spec/extensions/arbitrary_servers_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "arbtirary servers" do
   before do
     @db = Sequel.mock(:servers=>{})
-    @db.pool.extend Sequel::ArbitraryServers
+    @db.extension :arbitrary_servers
   end
 
   specify "should allow arbitrary server options using a hash" 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
 

data/spec/extensions/eval_inspect_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "eval_inspect extension" do
+  before do
+    @ds = Sequel.mock.dataset
+    @ds.meta_def(:supports_window_functions?){true}
+    @ds.meta_def(:literal_blob_append){|sql, s| sql << "X'#{s}'"}
+  end
+
+  specify "should make eval(obj.inspect) == obj for all Sequel::SQL::Expression subclasses" do
+    [
+      # Objects with components where eval(inspect) == self
+      Sequel::SQL::AliasedExpression.new(:b, :a),
+      Sequel::SQL::CaseExpression.new({:b=>:a}, :c),
+      Sequel::SQL::CaseExpression.new({:b=>:a}, :c, :d),
+      Sequel::SQL::Cast.new(:a, :b),
+      Sequel::SQL::ColumnAll.new(:a),
+      Sequel::SQL::ComplexExpression.new(:'=', :b, :a),
+      Sequel::SQL::Constant.new(:a),
+      Sequel::SQL::Function.new(:a, :b, :c),
+      Sequel::SQL::Identifier.new(:a),
+      Sequel::SQL::JoinClause.new(:inner, :b, :c),
+      Sequel::SQL::JoinOnClause.new({:d=>:a}, :inner, :b, :c),
+      Sequel::SQL::JoinUsingClause.new([:a], :inner, :b, :c),
+      Sequel::SQL::PlaceholderLiteralString.new('? = ?', [:a, :b]),
+      Sequel::SQL::PlaceholderLiteralString.new(':a = :b', [{:a=>:b, :b=>42}]),
+      Sequel::SQL::OrderedExpression.new(:a),
+      Sequel::SQL::OrderedExpression.new(:a, false),
+      Sequel::SQL::OrderedExpression.new(:a, false, :nulls=>:first),
+      Sequel::SQL::OrderedExpression.new(:a, false, :nulls=>:last),
+      Sequel::SQL::QualifiedIdentifier.new(:b, :a),
+      Sequel::SQL::Subscript.new(:a, [1, 2]),
+      Sequel::SQL::Window.new(:order=>:a, :partition=>:b),
+      Sequel::SQL::WindowFunction.new(Sequel::SQL::Function.new(:a, :b, :c), Sequel::SQL::Window.new(:order=>:a, :partition=>:b)),
+      Sequel::SQL::Wrapper.new(:a),
+      
+      # Objects with components where eval(inspect) != self
+      Sequel::SQL::AliasedExpression.new(Sequel::SQL::Blob.new('s'), :a),
+      Sequel::SQL::AliasedExpression.new(Sequel::LiteralString.new('s'), :a),
+      Sequel::SQL::PlaceholderLiteralString.new('(a, b) IN ?', [Sequel::SQL::ValueList.new([[1, 2]])]),
+      Sequel::SQL::CaseExpression.new({{:d=>Sequel::LiteralString.new('e')}=>:a}, :c, :d),
+      Sequel::SQL::AliasedExpression.new(Date.new(2011, 10, 11), :a),
+      Sequel::SQL::AliasedExpression.new(Sequel::SQLTime.create(10, 20, 30, 500000.125), :a),
+      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30), :a),
+      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30, 0.25), :a),
+      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30, -0.25), :a),
+      Sequel::SQL::AliasedExpression.new(Time.local(2011, 9, 11, 10, 20, 30), :a),
+      Sequel::SQL::AliasedExpression.new(Time.local(2011, 9, 11, 10, 20, 30, 500000.125), :a),
+      Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30), :a),
+      Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30, 500000.125), :a),
+      Sequel::SQL::AliasedExpression.new(BigDecimal.new('1.000000000000000000000000000000000000000000000001'), :a),
+    ].each do |o|
+      v = eval(o.inspect)
+      v.should == o
+      @ds.literal(v).should == @ds.literal(o)
+    end
+  end
+end

data/spec/extensions/json_serializer_spec.rb

@@ -1,10 +1,5 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-begin
-  require 'json'
-rescue LoadError => e
-  skip_warn "json_serializer plugin: can't load json (#{e.class}: #{e})"
-else
 describe "Sequel::Plugins::JsonSerializer" do
   before do
     class ::Artist < Sequel::Model
@@ -205,4 +200,3 @@ describe "Sequel::Plugins::JsonSerializer" do
     Object.send(:remove_const, :Artist3)
   end
 end
-end

data/spec/extensions/list_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), '/spec_helper')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe "List plugin" do
   def klass(opts={})

data/spec/extensions/looser_typecasting_spec.rb

@@ -4,18 +4,18 @@ describe "LooserTypecasting Extension" do
   before do
     @db = Sequel::Database.new({})
     def @db.schema(*args)
-      [[:id, {}], [:y, {:type=>:float}], [:b, {:type=>:integer}]]
+      [[:id, {}], [:z, {:type=>:float}], [:b, {:type=>:integer}]]
     end 
     @c = Class.new(Sequel::Model(@db[:items]))
     @c.instance_eval do
-      @columns = [:id, :b, :y] 
+      @columns = [:id, :b, :z] 
       def columns; @columns; end 
     end
   end
 
   specify "Should use to_i instead of Integer() for typecasting integers" do
     proc{@c.new(:b=>'a')}.should raise_error(Sequel::InvalidValue)
-    @db.extend(Sequel::LooserTypecasting)
+    @db.extension(:looser_typecasting)
     @c.new(:b=>'a').b.should == 0
 
     o = Object.new
@@ -26,14 +26,14 @@ describe "LooserTypecasting Extension" do
   end
 
   specify "Should use to_f instead of Float() for typecasting floats" do
-    proc{@c.new(:y=>'a')}.should raise_error(Sequel::InvalidValue)
-    @db.extend(Sequel::LooserTypecasting)
-    @c.new(:y=>'a').y.should == 0.0
+    proc{@c.new(:z=>'a')}.should raise_error(Sequel::InvalidValue)
+    @db.extension(:looser_typecasting)
+    @c.new(:z=>'a').z.should == 0.0
 
     o = Object.new
     def o.to_f
       1.0
     end
-    @c.new(:y=>o).y.should == 1.0
+    @c.new(:z=>o).z.should == 1.0
   end
 end

data/spec/extensions/many_through_many_spec.rb

@@ -21,6 +21,41 @@ describe Sequel::Model, "many_through_many" do
     Object.send(:remove_const, :Tag)
   end
 
+  it "should populate :key_hash and :id_map option correctly for custom eager loaders" do
+    khs = []
+    pr = proc{|h| khs << [h[:key_hash], h[:id_map]]}
+    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loader=>pr
+    @c1.eager(:tags).all
+    khs.should == [[{:id=>{1=>[Artist.load(:x=>1, :id=>1)]}}, {1=>[Artist.load(:x=>1, :id=>1)]}]]
+
+    khs.clear
+    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:id, :left_primary_key_column=>:i, :eager_loader=>pr
+    @c1.eager(:tags).all
+    khs.should == [[{:id=>{1=>[Artist.load(:x=>1, :id=>1)]}}, {1=>[Artist.load(:x=>1, :id=>1)]}]]
+  end
+
+  it "should support using a custom :left_primary_key option when eager loading many_to_many associations" do
+    @c1.send(:define_method, :id3){id*3}
+    @c1.dataset._fetch = {:id=>1}
+    @c2.dataset._fetch = {:id=>4, :x_foreign_key_x=>3}
+    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:id3
+    a = @c1.eager(:tags).all
+    a.should == [@c1.load(:id => 1)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists', "SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (3)))"]
+    a.first.tags.should == [@c2.load(:id=>4)]
+    MODEL_DB.sqls.should == []
+  end
+
+  it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do
+    @c1.dataset._fetch = {:id=>1}
+    @c2.dataset._fetch = {:id=>4, :x_foreign_key_x=>1}
+    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>Sequel./(:albums_artists__artist_id, 3)
+    a = @c1.eager(:tags).all
+    a.should == [@c1.load(:id => 1)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists', "SELECT tags.*, (albums_artists.artist_id / 3) AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND ((albums_artists.artist_id / 3) IN (1)))"]
+    a.first.tags.should == [@c2.load(:id=>4)]
+  end
+  
   it "should default to associating to other models in the same scope" do
     begin
       class ::AssociationModuleTest
@@ -598,6 +633,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
   it "should respect the :limit option on a many_through_many association with composite primary keys on the main table using a :window_function strategy" do
     Tag.dataset.meta_def(:supports_window_functions?){true}
     @c1.set_primary_key([:id1, :id2])
+    @c1.columns :id1, :id2
     @c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>true, :order=>:name
     @c1.dataset._fetch = [{:id1=>1, :id2=>2}]
     Tag.dataset._fetch = [{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}, {:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>6}]
@@ -934,3 +970,48 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     @c1.eager_graph(:tags, :albums).sql.should == 'SELECT artists.id, tags.id AS tags_id, albums_0.id AS albums_0_id FROM artists LEFT OUTER JOIN albums_artists ON ((albums_artists.artist_id = artists.id) AND (albums_artists.a = artists.b)) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON ((albums_artists_0.artist_id = artists.id) AND (albums_artists_0.c = artists.d)) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id)'
   end
 end
+
+describe "many_through_many associations with non-column expression keys" do
+  before do
+    @db = Sequel.mock(:fetch=>{:id=>1, :object_ids=>[2]})
+    @Foo = Class.new(Sequel::Model(@db[:foos]))
+    @Foo.columns :id, :object_ids
+    @Foo.plugin :many_through_many
+    m = Module.new{def obj_id; object_ids[0]; end}
+    @Foo.include m
+
+    @Foo.many_through_many :foos, [
+      [:f, Sequel.subscript(:l, 0), Sequel.subscript(:r, 0)],
+      [:f, Sequel.subscript(:l, 1), Sequel.subscript(:r, 1)]
+    ], :class=>@Foo, :left_primary_key=>:obj_id, :left_primary_key_column=>Sequel.subscript(:object_ids, 0), :right_primary_key=>Sequel.subscript(:object_ids, 0), :right_primary_key_method=>:obj_id
+    @foo = @Foo.load(:id=>1, :object_ids=>[2])
+    @db.sqls
+  end
+
+  it "should have working regular association methods" do
+    @Foo.first.foos.should == [@foo]
+    @db.sqls.should == ["SELECT * FROM foos LIMIT 1", "SELECT foos.* FROM foos INNER JOIN f ON (f.r[1] = foos.object_ids[0]) INNER JOIN f AS f_0 ON ((f_0.r[0] = f.l[1]) AND (f_0.l[0] = 2))"]
+  end
+
+  it "should have working eager loading methods" do
+    @db.fetch = [[{:id=>1, :object_ids=>[2]}], [{:id=>1, :object_ids=>[2], :x_foreign_key_x=>2}]]
+    @Foo.eager(:foos).all.map{|o| [o, o.foos]}.should == [[@foo, [@foo]]]
+    @db.sqls.should == ["SELECT * FROM foos", "SELECT foos.*, f_0.l[0] AS x_foreign_key_x FROM foos INNER JOIN f ON (f.r[1] = foos.object_ids[0]) INNER JOIN f AS f_0 ON ((f_0.r[0] = f.l[1]) AND (f_0.l[0] IN (2)))"]
+  end
+
+  it "should have working eager graphing methods" do
+    @db.fetch = {:id=>1, :object_ids=>[2], :foos_0_id=>1, :foos_0_object_ids=>[2]}
+    @Foo.eager_graph(:foos).all.map{|o| [o, o.foos]}.should == [[@foo, [@foo]]]
+    @db.sqls.should == ["SELECT foos.id, foos.object_ids, foos_0.id AS foos_0_id, foos_0.object_ids AS foos_0_object_ids FROM foos LEFT OUTER JOIN f ON (f.l[0] = foos.object_ids[0]) LEFT OUTER JOIN f AS f_0 ON (f_0.l[1] = f.r[0]) LEFT OUTER JOIN foos AS foos_0 ON (foos_0.object_ids[0] = f_0.r[1])"]
+  end
+
+  it "should have working filter by associations with model instances" do
+    @Foo.first(:foos=>@foo).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_ids[0] IN (SELECT f.l[0] FROM f INNER JOIN f AS f_0 ON (f_0.l[1] = f.r[0]) WHERE ((f_0.r[1] = 2) AND (f.l[0] IS NOT NULL)))) LIMIT 1"]
+  end
+
+  it "should have working filter by associations with model datasets" do
+    @Foo.first(:foos=>@Foo.where(:id=>@foo.id)).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_ids[0] IN (SELECT f.l[0] FROM f INNER JOIN f AS f_0 ON (f_0.l[1] = f.r[0]) WHERE ((f_0.r[1] IN (SELECT foos.object_ids[0] FROM foos WHERE ((id = 1) AND (foos.object_ids[0] IS NOT NULL)))) AND (f.l[0] IS NOT NULL)))) LIMIT 1"]
+  end
+end