sequel 4.14.0 → 4.15.0

data/spec/adapters/informix_spec.rb

@@ -91,4 +91,10 @@ describe "A Informix dataset" do
     @d.order(:value).first.should == {:name => 'abc', :value => 123}
     @d.order(:value).last.should == {:name => 'def', :value => 789}
   end
+
+  specify "should return last inserted id" do
+    first = @d.insert :name => 'abc', :value => 123
+    second = @d.insert :name => 'abc', :value => 123
+    (second - first).should == 1
+  end
 end

data/spec/adapters/postgres_spec.rb

@@ -276,6 +276,12 @@ describe "A PostgreSQL database" do
     Sequel.connect(DB.opts.merge(:notice_receiver=>proc{|r| a = r.result_error_message})){|db| db.do("BEGIN\nRAISE WARNING 'foo';\nEND;")}
     a.should == "WARNING:  foo\n"
   end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && DB.server_version >= 90000
+
+  specify "should support creating foreign tables" do
+    # This only tests the SQL created, because a true test using file_fdw or postgres_fdw
+    # requires superuser permissions, and you should not be running the tests as a superuser.
+    DB.send(:create_table_sql, :t, DB.create_table_generator{Integer :a}, :foreign=>:f, :options=>{:o=>1}).should == 'CREATE FOREIGN TABLE "t" ("a" integer) SERVER "f" OPTIONS (o \'1\')'
+  end
 end
 
 describe "A PostgreSQL database with domain types" do
@@ -2091,6 +2097,48 @@ describe 'PostgreSQL array handling' do
       @ds.insert(rs.first)
       @ds.all.should == rs
     end
+
+    @db.create_table!(:items) do
+      column :x, 'xml[]'
+      column :m, 'money[]'
+      column :b, 'bit[]'
+      column :vb, 'bit varying[]'
+      column :u, 'uuid[]'
+      column :xi, 'xid[]'
+      column :c, 'cid[]'
+      column :n, 'name[]'
+      column :t, 'tid[]'
+      column :i, 'int2vector[]'
+      column :o, 'oidvector[]'
+    end
+    @tp.call.should == [:xml_array, :money_array, :bit_array, :varbit_array, :uuid_array, :xid_array, :cid_array, :name_array, :tid_array, :int2vector_array, :oidvector_array]
+    @ds.insert(Sequel.pg_array(['<a></a>'], :xml),
+               Sequel.pg_array(['1'], :money),
+               Sequel.pg_array(['1'], :bit),
+               Sequel.pg_array(['10'], :varbit),
+               Sequel.pg_array(['c0f24910-39e7-11e4-916c-0800200c9a66'], :uuid),
+               Sequel.pg_array(['12'], :xid),
+               Sequel.pg_array(['12'], :cid),
+               Sequel.pg_array(['N'], :name),
+               Sequel.pg_array(['(1,2)'], :tid),
+               Sequel.pg_array(['1 2'], :int2vector),
+               Sequel.pg_array(['1 2'], :oidvector))
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      r = rs.first
+      m = r.delete(:m)
+      m.should_not be_a_kind_of(Array)
+      m.to_a.should be_a_kind_of(Array)
+      m.first.should be_a_kind_of(String)
+      r.should == {:x=>['<a></a>'], :b=>['1'], :vb=>['10'], :u=>['c0f24910-39e7-11e4-916c-0800200c9a66'], :xi=>['12'], :c=>['12'], :n=>['N'], :t=>['(1,2)'], :i=>['1 2'], :o=>['1 2']}
+      rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
+      rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
+      r[:m] = m
+      @ds.delete
+      @ds.insert(r)
+      @ds.all.should == rs
+    end
   end
 
   specify 'insert and retrieve empty arrays' do
@@ -2693,7 +2741,7 @@ describe 'PostgreSQL json type' do
         @db.get(jo.typeof).should == 'object'
         @db.get(ja.typeof).should == 'array'
         @db.from(ja.array_elements_text.as(:v)).select_map(:v).map{|s| s.gsub(' ', '')}.should == ['2', '3', '["a","b"]']
-        @db.from(jo.to_record(true).as(:v, [Sequel.lit('a integer'), Sequel.lit('b text')])).select_map(:a).should == [1]
+        @db.from(jo.to_record.as(:v, [Sequel.lit('a integer'), Sequel.lit('b text')])).select_map(:a).should == [1]
         @db.from(pg_json.call([{'a'=>1, 'b'=>1}]).op.to_recordset.as(:v, [Sequel.lit('a integer'), Sequel.lit('b integer')])).select_map(:a).should == [1]
 
         if json_type == :jsonb

data/spec/adapters/spec_helper.rb

@@ -16,6 +16,7 @@ rescue LoadError
 end
 
 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
 
 class Sequel::Database
@@ -50,7 +51,11 @@ RSPEC_EXAMPLE_GROUP.class_eval do
       end
     end
     if pending
-      specify(message){pending("Not yet working on #{Array(pending).join(', ')}", &block)}
+      specify(message) do
+        method = RSPEC_SKIP_PENDING && !ENV['SEQUEL_NO_SKIP_PENDING'] ? :skip : :pending
+        send(method, "Not yet working on #{Array(pending).join(', ')}")
+        instance_eval(&block)
+      end
     else
       specify(message, &block)
     end

data/spec/adapters/sqlite_spec.rb

@@ -123,7 +123,7 @@ describe "An SQLite database" do
     proc {@db.temp_store = :invalid}.should raise_error(Sequel::Error)
   end
   
-  cspecify "should support timestamps and datetimes and respect datetime_class", :do, :jdbc, :amalgalite, :swift do
+  cspecify "should support timestamps and datetimes and respect datetime_class", :do, :jdbc, :swift do
     @db.create_table!(:fk){timestamp :t; datetime :d}
     @db.use_timestamp_timezones = true
     t1 = Time.at(1)

data/spec/core/placeholder_literalizer_spec.rb

@@ -121,6 +121,16 @@ describe "Dataset::PlaceholderLiteralizer" do
     @db.sqls.should == ["SELECT * FROM items WHERE (a = 2)"]
   end
 
+  specify "should support modifying dataset used on per-call basis with #run" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
+    loader.with_dataset do |ds|
+      ds = ds.clone
+      ds.row_proc = lambda{|row| [row]}
+      ds
+    end.all(1).should == [[@h]]
+    @db.sqls.should == ["SELECT * FROM items WHERE (a = 1)"]
+  end
+  
   specify "should literalize args as NULL if :placeholder_literal_null is set" do
     loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg=>:a).clone(:placeholder_literal_null=>true)}
     loader.sql(1).should == "SELECT * FROM items WHERE (NULL = a)"

data/spec/extensions/date_arithmetic_spec.rb

@@ -142,6 +142,13 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:a, @h2)).should == "(CAST(a AS timestamp) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
   end
 
+  it "should correctly literalize on Fdbsql" do
+    db = dbf.call(:fdbsql)
+    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "(a + INTERVAL 1 day)"
+    db.literal(Sequel.date_add(:a, @h2)).should == "(a + INTERVAL 1 year + INTERVAL 1 month + INTERVAL 1 day + INTERVAL 1 hour + INTERVAL 1 minute + INTERVAL 1 second)"
+  end
+
   specify "should raise error if literalizing on an unsupported database" do
     db = Sequel.mock
     db.extension :date_arithmetic

data/spec/extensions/many_through_many_spec.rb

@@ -21,6 +21,20 @@ describe Sequel::Model, "many_through_many" do
     Object.send(:remove_const, :Tag)
   end
 
+  it "should raise an error if current class does not have a primary key, and :left_primary_key is not specified" do
+    @c1.no_primary_key
+    proc{@c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]}.should raise_error(Sequel::Error)
+    DB.sqls.should == []
+  end
+  
+  it "should raise an error if associated class does not have a primary key, and :right_primary_key is not specified" do
+    @c2.no_primary_key
+    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    n = @c1.load(:id => 1234)
+    proc{n.tags}.should raise_error(Sequel::Error)
+    DB.sqls.should == []
+  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]]}

data/spec/extensions/migration_spec.rb

@@ -138,7 +138,7 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
         add_spatial_index :e, :name=>'e_s'
         rename_column :e, :g
       end
-      create_view(:c, 'SELECT * FROM b')
+      create_view(:c, 'SELECT * FROM b', :foo=>:bar)
       create_join_table(:cat_id=>:cats, :dog_id=>:dogs)
     end
   end
@@ -163,7 +163,7 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
         [:add_spatial_index, :e, {:name=>"e_s"}],
         [:rename_column, :e, :g]]
       ],
-      [:create_view, :c, "SELECT * FROM b"],
+      [:create_view, :c, "SELECT * FROM b", {:foo=>:bar}],
       [:create_join_table, {:cat_id=>:cats, :dog_id=>:dogs}]]
   end
 
@@ -172,7 +172,7 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
     Sequel.migration{change(&p)}.apply(@db, :down)
     @db.actions.should == [
       [:drop_join_table, {:cat_id=>:cats, :dog_id=>:dogs}],
-      [:drop_view, :c],
+      [:drop_view, :c, {:foo=>:bar}],
       [:alter_table, [
         [:rename_column, :g, :e],
         [:drop_index, :e, {:name=>"e_s"}],

data/spec/extensions/pg_array_associations_spec.rb

@@ -148,6 +148,15 @@ describe Sequel::Model, "pg_array_associations" do
     @c2.filter(:artists=>@c1.where(:id=>1)).sql.should == "SELECT * FROM tags WHERE ((tags.id * 3) IN (SELECT unnest(artists.tag_ids[1:2]) FROM artists WHERE (id = 1)))"
   end
   
+  it "should raise an error if associated model does not have a primary key, and :primary_key is not specified" do
+    @c1.no_primary_key
+    @c2.no_primary_key
+    @c1.pg_array_to_many :tags, :clone=>:tags
+    proc{@o1.tags}.should raise_error(Sequel::Error)
+    proc{@c2.many_to_pg_array :artists, :clone=>:artists}.should raise_error(Sequel::Error)
+    @db.sqls.should == []
+  end
+  
   it "should support a :key option" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :key=>:tag2_ids
     @c2.many_to_pg_array :artists, :clone=>:artists, :key=>:tag2_ids

data/spec/extensions/pg_json_ops_spec.rb

@@ -112,17 +112,13 @@ describe "Sequel::Postgres::JSONOp" do
   end
 
   it "should have #to_record use the json_to_record function" do
-    @l[@j.to_record].should == "json_to_record(j, false)"
-    @l[@jb.to_record].should == "jsonb_to_record(j, false)"
-    @l[@j.to_record(true)].should == "json_to_record(j, true)"
-    @l[@jb.to_record(true)].should == "jsonb_to_record(j, true)"
+    @l[@j.to_record].should == "json_to_record(j)"
+    @l[@jb.to_record].should == "jsonb_to_record(j)"
   end
 
   it "should have #to_recordset use the json_to_recordsetfunction" do
-    @l[@j.to_recordset].should == "json_to_recordset(j, false)"
-    @l[@jb.to_recordset].should == "jsonb_to_recordset(j, false)"
-    @l[@j.to_recordset(true)].should == "json_to_recordset(j, true)"
-    @l[@jb.to_recordset(true)].should == "jsonb_to_recordset(j, true)"
+    @l[@j.to_recordset].should == "json_to_recordset(j)"
+    @l[@jb.to_recordset].should == "jsonb_to_recordset(j)"
   end
 
   it "should have #populate use the json_populate_record function" do

data/spec/extensions/schema_dumper_spec.rb

@@ -753,6 +753,15 @@ end
 END_MIG
   end
 
+  it "should force specify :null option for MySQL timestamp columns when using :same_db" do
+    @d.meta_def(:database_type){:mysql}
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>true}]]}
+    @d.dump_table_schema(:t3, :same_db=>true).should == "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>true\n  \n  primary_key [:c1]\nend"
+
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>false}]]}
+    @d.dump_table_schema(:t3, :same_db=>true).should == "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>false\n  \n  primary_key [:c1]\nend"
+  end
+
   it "should use separate primary_key call with non autoincrementable types" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'varchar(8)', :primary_key=>true}]]}
     @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  String :c1, :size=>8\n  \n  primary_key [:c1]\nend"

data/spec/extensions/spec_helper.rb

@@ -91,3 +91,6 @@ if ENV['SEQUEL_COLUMNS_INTROSPECTION']
   Sequel::Database.extension :columns_introspection
   Sequel::Mock::Dataset.send(:include, Sequel::ColumnsIntrospection)
 end
+if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
+  Sequel::Model.cache_associations = false
+end

data/spec/extensions/split_values_spec.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::SplitValues" do
+  it "should skip the refresh after saving a new object" do
+    c = Class.new(Sequel::Model(:a))
+    c.columns :id, :x
+    c.plugin :split_values
+    c.dataset._fetch = {:id=>1, :x=>2, :y=>3}
+    o = c.first
+    c.db.reset
+
+    o.should == c.load(:id=>1, :x=>2)
+    o[:id].should == 1
+    o[:x].should == 2
+    o[:y].should == 3
+    {c.load(:id=>1, :x=>2)=>4}[o].should == 4
+    o.values.should == {:id=>1, :x=>2}
+
+    o.save
+    c.db.sqls.should == ["UPDATE a SET x = 2 WHERE (id = 1)"]
+  end
+end

data/spec/integration/database_test.rb

@@ -53,7 +53,7 @@ describe Sequel::Database do
       proc{@db[:test].update(:a=>'1', :b=>'2')}.should raise_error(Sequel::UniqueConstraintViolation)
     end
 
-    cspecify "should raise Sequel::CheckConstraintViolation when a check constraint is violated", :mysql, [:db2], [proc{|db| db.sqlite_version < 30802}, :sqlite] do
+    cspecify "should raise Sequel::CheckConstraintViolation when a check constraint is violated", :mysql, [:db2], [proc{|db| db.sqlite_version < 30802}, :sqlite], :fdbsql do
       @db.create_table!(:test){String :a; check Sequel.~(:a=>'1')}
       proc{@db[:test].insert('1')}.should raise_error(Sequel::CheckConstraintViolation)
       @db[:test].insert('2')

data/spec/integration/dataset_test.rb

@@ -851,7 +851,7 @@ describe Sequel::SQL::Constants do
     d.to_s.should == Date.today.to_s
   end
 
-  cspecify "should have working CURRENT_TIME", [:do, :mysql], [:jdbc, :sqlite], [:mysql2] do
+  cspecify "should have working CURRENT_TIME", [:jdbc, :sqlite], [:mysql2] do
     @db.create_table!(:constants){Time :t, :only_time=>true}
     @ds.insert(:t=>Sequel::CURRENT_TIME)
     (Time.now - @c[@ds.get(:t)]).should be_within(60).of(0)

data/spec/integration/eager_loader_test.rb

@@ -330,7 +330,7 @@ describe "Polymorphic Associations" do
     end
     class ::Asset < Sequel::Model
       m = method(:constantize)
-      many_to_one :attachable, :reciprocal=>:assets,
+      many_to_one :attachable, :reciprocal=>:assets, :reciprocal_type=>:one_to_many,
         :setter=>(proc do |attachable|
           self[:attachable_id] = (attachable.pk if attachable)
           self[:attachable_type] = (attachable.class.name if attachable)

data/spec/integration/plugin_test.rb

@@ -334,7 +334,7 @@ describe "Many Through Many Plugin" do
     c.exclude(:related_artists=>c.filter(:artists__id=>@artist1.id)).all.map{|a| a.name}.sort.should == %w'3'
   end
 
-  specify "should handle extreme case with 5 join tables" do
+  cspecify "should handle extreme case with 5 join tables", :fdbsql do
     Artist.many_through_many :related_albums, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id], [:artists, :id, :id], [:albums_artists, :artist_id, :album_id]], :class=>Album, :distinct=>true
     @db[:albums_artists].delete
     @album1.add_artist(@artist1)
@@ -455,6 +455,7 @@ describe "Tactical Eager Loading Plugin" do
   before(:all) do
     @db = DB
     @db.instance_variable_set(:@schemas, {})
+    @db.drop_table?(:albums_artists) # work around fdbsql disconnect bug
     @db.create_table!(:artists) do
       primary_key :id
       String :name
@@ -2068,7 +2069,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
       it_should_behave_like "constraint validations"
     end
   end
-end
+end unless DB.database_type == :fdbsql # doesn't handle check constraints
 
 describe "date_arithmetic extension" do
   asd = begin

data/spec/integration/prepared_statement_test.rb

@@ -161,7 +161,7 @@ describe "Prepared Statements and Bound Arguments" do
     @db.call(:select_n, :n=>10){|r| r[:numb] *= 2}.should == [20]
   end
     
-  specify "should support prepared statements being called multiple times with different arguments" do
+  cspecify "should support prepared statements being called multiple times with different arguments", [:jdbc, :fdbsql] do
     @ds.filter(:numb=>:$n).prepare(:select, :select_n)
     @db.call(:select_n, :n=>10).should == [{:id=>1, :numb=>10}]
     @db.call(:select_n, :n=>0).should == []
@@ -304,7 +304,7 @@ describe "Bound Argument Types" do
     @ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>@vs[:dt])[:dt].should == @vs[:dt]
   end
 
-  cspecify "should handle datetime type with fractional seconds", [:do], [:mysql2], [:jdbc, :sqlite], [:tinytds], [:oracle] do
+  cspecify "should handle datetime type with fractional seconds", [:do, :postgres], [:jdbc, :sqlite], [:oracle] do
     Sequel.datetime_class = DateTime
     fract_time = DateTime.parse('2010-10-12 13:14:15.500000')
     @ds.prepare(:update, :ps_datetime_up, :dt=>:$x).call(:x=>fract_time)
@@ -315,7 +315,7 @@ describe "Bound Argument Types" do
     @ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>@vs[:t])[:t].should == @vs[:t]
   end
 
-  cspecify "should handle time type with fractional seconds", [:do], [:jdbc, :sqlite], [:oracle], [:swift, :postgres] do
+  cspecify "should handle time type with fractional seconds", [:do, :postgres], [:jdbc, :sqlite], [:oracle], [:swift, :postgres] do
     fract_time = @vs[:t] + 0.5
     @ds.prepare(:update, :ps_time_up, :t=>:$x).call(:x=>fract_time)
     @ds.literal(@ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>fract_time)[:t]).should == @ds.literal(fract_time)

data/spec/integration/schema_test.rb

@@ -364,7 +364,7 @@ describe "Database schema modifiers" do
     end
   end
 
-  specify "should create temporary tables without raising an exception" do
+  cspecify "should create temporary tables without raising an exception", :fdbsql do
     @db.create_table!(:items_temp, :temp=>true){Integer :number}
   end
 
@@ -420,7 +420,7 @@ describe "Database schema modifiers" do
     @ds.insert([10])
   end
 
-  specify "should be able to specify constraint names for column constraints" do
+  cspecify "should be able to specify constraint names for column constraints", :fdbsql do
     @db.create_table!(:items2){primary_key :id, :primary_key_constraint_name=>:foo_pk}
     @db.create_table!(:items){foreign_key :id, :items2, :unique=>true, :foreign_key_constraint_name => :foo_fk, :unique_constraint_name => :foo_uk, :null=>false}
     @db.alter_table(:items){drop_constraint :foo_fk, :type=>:foreign_key; drop_constraint :foo_uk, :type=>:unique}
@@ -681,7 +681,7 @@ describe "Database schema modifiers" do
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
   end
 
-  cspecify "should work correctly with many operations in a single alter_table call", [:jdbc, :db2], [:db2] do
+  cspecify "should work correctly with many operations in a single alter_table call", [:jdbc, :db2], [:db2], :fdbsql do
     @db.create_table!(:items) do
       primary_key :id
       String :name2

data/spec/integration/spec_helper.rb

@@ -17,6 +17,7 @@ end
 Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_(spec|test)\.rb/}
 
 Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
 Sequel::Model.use_transactions = false
 Sequel.cache_anonymous_models = false
 
@@ -74,7 +75,11 @@ RSPEC_EXAMPLE_GROUP.class_eval do
   
   def self.cspecify(message, *checked, &block)
     if pending = Sequel.guarded?(*checked)
-      specify(message){pending("Not yet working on #{Array(pending).map{|x| x.is_a?(Proc) ? :proc : x}.join(', ')}", &block)}
+      specify(message) do
+        method = RSPEC_SKIP_PENDING && !ENV['SEQUEL_NO_SKIP_PENDING'] ? :skip : :pending
+        send(method, "Not yet working on #{Array(pending).map{|x| x.is_a?(Proc) ? :proc : x}.join(', ')}")
+        instance_eval(&block)
+      end
     else
       specify(message, &block)
     end

data/spec/integration/timezone_test.rb

@@ -65,7 +65,7 @@ describe "Sequel timezone support" do
     test_timezone
   end
 
-  cspecify "should support using local time for both database storage and for application", [:do, :mysql], [:do, :postgres], [:oracle], [:swift, :postgres], [:swift, :mysql] do
+  cspecify "should support using local time for both database storage and for application", [:do, :postgres], [:oracle], [:swift, :postgres], [:swift, :mysql] do
     Sequel.default_timezone = :local
     test_timezone
     Sequel.database_timezone = :utc

data/spec/model/association_reflection_spec.rb

@@ -64,6 +64,13 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     @c.association_reflection(:c).reciprocal.should == :xx
   end
 
+  it "should not raise an error if some reciprocal associations have invalid associated classes" do
+    @c = Class.new(Sequel::Model(:foo))
+    @c.one_to_many :sadfakloasdfioas
+    @c.many_to_one :c, :class=>@c
+    proc{@c.association_reflection(:c).reciprocal}.should_not raise_error
+  end
+
   it "should require the associated class is the current class to be a reciprocal" do
     ParParent.many_to_one :par_parent_two, :key=>:blah
     ParParent.many_to_one :par_parent_three, :key=>:blah
@@ -469,3 +476,25 @@ describe Sequel::Model, " association reflection methods" do
     c.instance_methods.map{|x| x.to_s}.should include('parent')
   end
 end
+
+describe Sequel::Model::Associations::AssociationReflection, "with caching disabled" do
+  before do
+    @c = Class.new(Sequel::Model(:foo))
+  end
+  after do
+    Object.send(:remove_const, :ParParent)
+  end
+
+  it "should not cache metadata" do
+    class ::ParParent < Sequel::Model; end
+    c = ParParent
+    @c.cache_associations = false
+    @c.many_to_one :c, :class=>:ParParent
+    @c.association_reflection(:c).associated_class.should == c
+    Object.send(:remove_const, :ParParent)
+    class ::ParParent < Sequel::Model; end
+    c = ParParent
+    @c.association_reflection(:c).associated_class.should == c
+  end
+end
+