sequel 3.48.0 → 4.0.0

data/spec/extensions/pg_array_ops_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+Sequel.extension :pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops
+
 describe "Sequel::Postgres::ArrayOp" do
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
@@ -18,6 +20,10 @@ describe "Sequel::Postgres::ArrayOp" do
     @db.literal(@a[1][2]).should == "a[1][2]"
   end
 
+  it "#[] with a range should return an ArrayOp" do
+    @db.literal(@a[1..2].any).should == "ANY(a[1:2])"
+  end
+
   it "#any should use the ANY method" do
     @db.literal(1=>@a.any).should == "(1 = ANY(a))"
   end
@@ -43,6 +49,16 @@ describe "Sequel::Postgres::ArrayOp" do
     @db.literal(@a.concat(:b)).should == "(a || b)"
   end
 
+  it "#remove should remove the element from the array" do
+    @db.literal(@a.remove(1)).should == "array_remove(a, 1)"
+    @db.literal(@a.remove(1)[2]).should == "array_remove(a, 1)[2]"
+  end
+
+  it "#remove should replace the element in the array with another" do
+    @db.literal(@a.replace(1, 2)).should == "array_replace(a, 1, 2)"
+    @db.literal(@a.replace(1, 2)[3]).should == "array_replace(a, 1, 2)[3]"
+  end
+
   it "#unshift should use the || operator in prepend mode" do
     @db.literal(@a.unshift(:b)).should == "(b || a)"
   end
@@ -68,6 +84,15 @@ describe "Sequel::Postgres::ArrayOp" do
     @db.literal(@a.join(':', '*')).should == "array_to_string(a, ':', '*')"
   end
 
+  it "#hstore should convert the item to an hstore using the hstore function" do
+    @db.literal(@a.hstore).should == "hstore(a)"
+    @db.literal(@a.hstore['a']).should == "(hstore(a) -> 'a')"
+    @db.literal(@a.hstore(:b)).should == "hstore(a, b)"
+    @db.literal(@a.hstore(:b)['a']).should == "(hstore(a, b) -> 'a')"
+    @db.literal(@a.hstore(%w'1')).should == "hstore(a, ARRAY['1'])"
+    @db.literal(@a.hstore(%w'1')['a']).should == "(hstore(a, ARRAY['1']) -> 'a')"
+  end
+
   it "#unnest should use the unnest function" do
     @db.literal(@a.unnest).should == "unnest(a)"
   end

data/spec/extensions/pg_array_spec.rb

@@ -2,10 +2,13 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "pg_array extension" do
   before(:all) do
+    Sequel.extension :pg_array
     @pg_types = Sequel::Postgres::PG_TYPES.dup
+    @pg_named_types = Sequel::Postgres::PG_NAMED_TYPES.dup
   end
   after(:all) do
     Sequel::Postgres::PG_TYPES.replace(@pg_types)
+    Sequel::Postgres::PG_NAMED_TYPES.replace(@pg_named_types)
   end
 
   before do
@@ -357,10 +360,15 @@ describe "pg_array extension" do
     @db.typecast_value(:banana_array, %w'1 2').should == [1,2]
   end
 
-  it "should set appropriate timestamp conversion procs when getting conversion procs" do
+  it "should set appropriate timestamp conversion procs when resetting conversion procs" do
+    Sequel::Postgres::PG_NAMED_TYPES[:foo] = proc{|v| v*2}
+    @db.fetch = [[{:oid=>2222, :typname=>'foo'}], [{:oid=>2222, :typarray=>2223, :typname=>'foo'}]]
+    @db.reset_conversion_procs
     procs = @db.conversion_procs
     procs[1185].call('{"2011-10-20 11:12:13"}').should == [Time.local(2011, 10, 20, 11, 12, 13)]
     procs[1115].call('{"2011-10-20 11:12:13"}').should == [Time.local(2011, 10, 20, 11, 12, 13)]
+    procs[2222].call('1').should == '11'
+    procs[2223].call('{"2"}').should == ['22']
   end
 
   it "should return correct results for Database#schema_type_class" do

data/spec/extensions/pg_hstore_ops_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+Sequel.extension :pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops
+
 describe "Sequel::Postgres::HStoreOp" do
   before do
     @ds = Sequel.connect('mock://postgres', :quote_identifiers=>false).dataset
@@ -42,6 +44,17 @@ describe "Sequel::Postgres::HStoreOp" do
     @ds.literal(@h[%w'a'][0]).should == "(h -> ARRAY['a'])[0]"
   end
 
+  it "#[] should not return a PGArrayOp if given an array but pg_array_op is not supported" do
+    begin
+      module Sequel::Postgres::HStoreOp::Sequel
+        SQL = ::Sequel::SQL
+      end
+      @ds.literal(@h[%w'a']).should_not be_a_kind_of(Sequel::Postgres::ArrayOp)
+    ensure
+      Sequel::Postgres::HStoreOp.send(:remove_const, :Sequel)
+    end
+  end
+
   it "#[] should return a PGArrayOp if given a PGArray" do
     @ds.literal(@h[Sequel.pg_array(%w'a')][0]).should == "(h -> ARRAY['a'])[0]"
   end

data/spec/extensions/pg_hstore_spec.rb

@@ -2,6 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "pg_hstore extension" do
   before do
+    Sequel.extension :pg_array, :pg_hstore
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
     @m = Sequel::Postgres
     @c = @m::HStore

data/spec/extensions/pg_json_ops_spec.rb

@@ -0,0 +1,131 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+Sequel.extension :pg_array, :pg_array_ops, :pg_json, :pg_json_ops
+
+describe "Sequel::Postgres::JSONOp" do
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @j = Sequel.pg_json_op(:j)
+    @l = proc{|o| @db.literal(o)}
+  end
+
+  it "should have #[] get the element" do
+    @l[@j[1]].should == "(j -> 1)"
+    @l[@j['a']].should == "(j -> 'a')"
+  end
+
+  it "should have #[] accept an array" do
+    @l[@j[%w'a b']].should == "(j #> ARRAY['a','b'])"
+    @l[@j[Sequel.pg_array(%w'a b')]].should == "(j #> ARRAY['a','b'])"
+    @l[@j[Sequel.pg_array(:a)]].should == "(j #> a)"
+  end
+
+  it "should have #[] return a JSONOp" do
+    @l[@j[1][2]].should == "((j -> 1) -> 2)"
+    @l[@j[%w'a b'][2]].should == "((j #> ARRAY['a','b']) -> 2)"
+  end
+
+  it "should have #get be an alias to #[]" do
+    @l[@j.get(1)].should == "(j -> 1)"
+    @l[@j.get(%w'a b')].should == "(j #> ARRAY['a','b'])"
+  end
+
+  it "should have #get_text get the element as text" do
+    @l[@j.get_text(1)].should == "(j ->> 1)"
+    @l[@j.get_text('a')].should == "(j ->> 'a')"
+  end
+
+  it "should have #get_text accept an array" do
+    @l[@j.get_text(%w'a b')].should == "(j #>> ARRAY['a','b'])"
+    @l[@j.get_text(Sequel.pg_array(%w'a b'))].should == "(j #>> ARRAY['a','b'])"
+    @l[@j.get_text(Sequel.pg_array(:a))].should == "(j #>> a)"
+  end
+
+  it "should have #get_text return an SQL::StringExpression" do
+    @l[@j.get_text(1) + 'a'].should == "((j ->> 1) || 'a')"
+    @l[@j.get_text(%w'a b') + 'a'].should == "((j #>> ARRAY['a','b']) || 'a')"
+  end
+
+  it "should have #array_length use the json_array_length function" do
+    @l[@j.array_length].should == "json_array_length(j)"
+  end
+
+  it "should have #array_length return a numeric expression" do
+    @l[@j.array_length & 1].should == "(json_array_length(j) & 1)"
+  end
+
+  it "should have #each use the json_each function" do
+    @l[@j.each].should == "json_each(j)"
+  end
+
+  it "should have #each_text use the json_each_text function" do
+    @l[@j.each_text].should == "json_each_text(j)"
+  end
+
+  it "should have #extract use the json_extract_path function" do
+    @l[@j.extract('a')].should == "json_extract_path(j, 'a')"
+    @l[@j.extract('a', 'b')].should == "json_extract_path(j, 'a', 'b')"
+  end
+
+  it "should have #extract return a JSONOp" do
+    @l[@j.extract('a')[1]].should == "(json_extract_path(j, 'a') -> 1)"
+  end
+
+  it "should have #extract_text use the json_extract_path_text function" do
+    @l[@j.extract_text('a')].should == "json_extract_path_text(j, 'a')"
+    @l[@j.extract_text('a', 'b')].should == "json_extract_path_text(j, 'a', 'b')"
+  end
+
+  it "should have #extract_text return an SQL::StringExpression" do
+    @l[@j.extract_text('a') + 'a'].should == "(json_extract_path_text(j, 'a') || 'a')"
+  end
+
+  it "should have #keys use the json_object_keys function" do
+    @l[@j.keys].should == "json_object_keys(j)"
+  end
+
+  it "should have #array_elements use the json_array_elements function" do
+    @l[@j.array_elements].should == "json_array_elements(j)"
+  end
+
+  it "should have #populate use the json_populate_record function" do
+    @l[@j.populate(:a)].should == "json_populate_record(a, j)"
+  end
+
+  it "should have #populate_set use the json_populate_record function" do
+    @l[@j.populate_set(:a)].should == "json_populate_recordset(a, j)"
+  end
+
+  it "#pg_json should return self" do
+    @j.pg_json.should equal(@j)
+  end
+
+  it "Sequel.pg_json_op should return arg for JSONOp" do
+    Sequel.pg_json_op(@j).should equal(@j)
+  end
+
+  it "should be able to turn expressions into json ops using pg_json" do
+    @db.literal(Sequel.qualify(:b, :a).pg_json[1]).should == "(b.a -> 1)"
+    @db.literal(Sequel.function(:a, :b).pg_json[1]).should == "(a(b) -> 1)"
+  end
+
+  it "should be able to turn literal strings into json ops using pg_json" do
+    @db.literal(Sequel.lit('a').pg_json[1]).should == "(a -> 1)"
+  end
+
+  it "should be able to turn symbols into json ops using Sequel.pg_json_op" do
+    @db.literal(Sequel.pg_json_op(:a)[1]).should == "(a -> 1)"
+  end
+
+  it "should be able to turn symbols into json ops using Sequel.pg_json" do
+    @db.literal(Sequel.pg_json(:a)[1]).should == "(a -> 1)"
+  end
+
+  it "should allow transforming JSONArray instances into ArrayOp instances" do
+    @db.literal(Sequel.pg_json([1,2]).op[1]).should == "('[1,2]'::json -> 1)"
+  end
+
+  it "should allow transforming JSONHash instances into ArrayOp instances" do
+    @db.literal(Sequel.pg_json('a'=>1).op['a']).should == "('{\"a\":1}'::json -> 'a')"
+  end
+end

data/spec/extensions/pg_json_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+Sequel.extension :pg_array, :pg_json
+
 describe "pg_json extension" do
   before(:all) do
     m = Sequel::Postgres
@@ -36,6 +38,14 @@ describe "pg_json extension" do
     @m.parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.should == {'a'=>'b', 'c'=>{'d'=>'e'}}
   end
 
+  it "should parse json and non-json plain strings, integers, and floats correctly in db_parse_json" do
+    @m.db_parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.should == {'a'=>'b', 'c'=>{'d'=>'e'}}
+    @m.db_parse_json('[1, [2], {"a": "b"}]').to_a.should == [1, [2], {'a'=>'b'}]
+    @m.db_parse_json('1').should == 1
+    @m.db_parse_json('"b"').should == 'b'
+    @m.db_parse_json('1.1').should == 1.1
+  end
+
   it "should raise an error when attempting to parse invalid json" do
     proc{@m.parse_json('')}.should raise_error(Sequel::InvalidValue)
     proc{@m.parse_json('1')}.should raise_error(Sequel::InvalidValue)
@@ -69,10 +79,6 @@ describe "pg_json extension" do
     Sequel.pg_json(a).should equal(a)
   end
 
-  it "should have Sequel.pg_json raise an Error if called with a non-hash or array" do
-    proc{Sequel.pg_json(:a)}.should raise_error(Sequel::Error)
-  end
-
   it "should have JSONHash#to_hash method for getting underlying hash" do
     Sequel.pg_json({}).to_hash.should be_a_kind_of(Hash)
   end

data/spec/extensions/pg_range_ops_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+Sequel.extension :pg_array, :pg_range, :pg_range_ops
+
 describe "Sequel::Postgres::RangeOp" do
   before do
     @ds = Sequel.connect('mock://postgres', :quote_identifiers=>false).dataset
@@ -38,11 +40,6 @@ describe "Sequel::Postgres::RangeOp" do
     @ds.literal(@h.adjacent_to(@h)).should == "(h -|- h)"
   end
 
-  qspecify "should define methods for the deprecated PostgreSQL range operators" do
-    @ds.literal(@h.starts_before(@h)).should == "(h &< h)"
-    @ds.literal(@h.ends_after(@h)).should == "(h &> h)"
-  end
-
   it "should define methods for all of the PostgreSQL range functions" do
     @ds.literal(@h.lower).should == "lower(h)"
     @ds.literal(@h.upper).should == "upper(h)"

data/spec/extensions/pg_range_spec.rb

@@ -1,7 +1,9 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+
 describe "pg_range extension" do
   before(:all) do
+    Sequel.extension :pg_array, :pg_range
     @pg_types = Sequel::Postgres::PG_TYPES.dup
   end
   after(:all) do
@@ -213,13 +215,15 @@ describe "pg_range extension" do
     end
   end
 
-  it "should set appropriate timestamp range conversion procs when getting conversion procs" do
+  it "should set appropriate timestamp range conversion procs when resetting conversion procs" do
+    @db.reset_conversion_procs
     procs = @db.conversion_procs
     procs[3908].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').should == (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
     procs[3910].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').should == (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
   end
 
-  it "should set appropriate timestamp range array conversion procs when getting conversion procs" do
+  it "should set appropriate timestamp range array conversion procs when resetting conversion procs" do
+    @db.reset_conversion_procs
     procs = @db.conversion_procs
     procs[3909].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').should == [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]
     procs[3911].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').should == [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]

data/spec/extensions/pg_row_ops_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+Sequel.extension :pg_array, :pg_array_ops, :pg_row, :pg_row_ops
+
 describe "Sequel::Postgres::PGRowOp" do
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -19,6 +19,7 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @Artist.plugin :prepared_statements_associations
     @Album.plugin :prepared_statements_associations
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Artist.one_to_one :album, :class=>@Album, :key=>:artist_id
     @Album.many_to_one :artist, :class=>@Artist
     @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
     @Artist.plugin :many_through_many
@@ -30,6 +31,9 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @Artist.load(:id=>1).albums
     @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1) -- prepared"]
 
+    @Artist.load(:id=>1).album
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1) LIMIT 1 -- prepared"]
+
     @Album.load(:id=>1, :artist_id=>2).artist
     @db.sqls.should == ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- prepared"]
 
@@ -42,6 +46,7 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
 
   specify "should run correct SQL for composite key associations" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
+    @Artist.one_to_one :album, :class=>@Album, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
     @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
     @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>[:album_id, :album_id2], :right_key=>[:tag_id, :tag_id2], :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
     @Artist.many_through_many :tags, [[:albums, [:artist_id, :artist_id2], [:id, :id2]], [:albums_tags, [:album_id, :album_id2], [:tag_id, :tag_id2]]], :class=>@Tag, :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
@@ -49,6 +54,9 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @Artist.load(:id=>1, :id2=>2).albums
     @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
 
+    @Artist.load(:id=>1, :id2=>2).album
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) LIMIT 1 -- prepared"]
+
     @Album.load(:id=>1, :artist_id=>2, :artist_id2=>3).artist
     @db.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 2) AND (artists.id2 = 3)) LIMIT 1 -- prepared"]
 
@@ -89,10 +97,23 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
   end
 
-  specify "should run a regular query if :conditions option is used when defining the association" do
-    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+  specify "should use a prepared statement if the associated dataset has conditions" do
+    @Album.dataset = @Album.dataset.where(:a=>2)
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 2) AND (albums.artist_id = 1)) -- prepared"]
+  end
+
+  specify "should use a prepared statement if the :conditions association option" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>2} 
     @Artist.load(:id=>1).albums
-    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 1) AND (albums.artist_id = 1))"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 2) AND (albums.artist_id = 1)) -- prepared"]
+  end
+
+  specify "should not use a prepared statement if :conditions association option uses an identifier" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{Sequel.identifier('a')=>2}
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 2) AND (albums.artist_id = 1)) -- prepared"]
   end
 
   specify "should run a regular query if :dataset option is used when defining the association" do
@@ -103,9 +124,9 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
   end
 
   specify "should run a regular query if :cloning an association that doesn't used prepared statements" do
-    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id do |ds| ds end
     @Artist.one_to_many :oalbums, :clone=>:albums
     @Artist.load(:id=>1).oalbums
-    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 1) AND (albums.artist_id = 1))"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
   end
 end

data/spec/extensions/rcte_tree_spec.rb

@@ -2,14 +2,14 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "rcte_tree" do
   before do
-    @c = Class.new(Sequel::Model(MODEL_DB[:nodes]))
+    @c = Class.new(Sequel::Model(DB[:nodes]))
     @c.class_eval do
       def self.name; 'Node'; end
       columns :id, :name, :parent_id, :i, :pi
     end
     @ds = @c.dataset
     @o = @c.load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
-    MODEL_DB.reset
+    DB.reset
   end
 
   it "should define the correct associations" do
@@ -102,7 +102,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>1}, {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>2},
        {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]]
     os = @ds.eager(:ancestors).all
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(id IN \([12], [12]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D'), @c.load(:id=>9, :parent_id=>nil, :name=>'E')]
@@ -114,7 +114,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.parent.parent if o.parent}.should == [@c.load(:id=>8, :name=>'?', :parent_id=>nil), @c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil), nil]
     os.map{|o| o.parent.parent.parent if o.parent and o.parent.parent}.should == [nil, @c.load(:id=>8, :name=>'?', :parent_id=>nil), nil, nil]
     os.map{|o| o.parent.parent.parent.parent if o.parent and o.parent.parent and o.parent.parent.parent}.should == [nil, nil, nil, nil]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should eagerly load ancestors when giving options" do
@@ -124,7 +124,7 @@ describe Sequel::Model, "rcte_tree" do
        {:i=>1, :name=>'00', :pi=>8, :kal=>1}, {:i=>1, :name=>'00', :pi=>8, :kal=>2},
        {:i=>8, :name=>'?', :pi=>nil, :kal=>2}, {:i=>8, :name=>'?', :pi=>nil, :kal=>1}]]
     os = @ds.eager(:as).all
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH cte AS \(SELECT i AS kal, nodes\.\* FROM nodes WHERE \(i IN \([12], [12]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.pi = nodes\.i\)\) SELECT \* FROM cte/
     os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D'), @c.load(:i=>9, :pi=>nil, :name=>'E')]
@@ -145,7 +145,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>1}, {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>2},
        {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]]
     @ds.eager(:ancestors).all
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(id IN \([12], [12]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
   end
@@ -157,7 +157,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2},
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]]
     os = @ds.eager(:descendants).all
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
@@ -167,7 +167,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.children}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E')], [@c.load(:id=>3, :name=>'00', :parent_id=>6)], [@c.load(:id=>4, :name=>'?', :parent_id=>7)]]
     os.map{|o1| o1.children.map{|o2| o2.children}}.should == [[[@c.load(:id=>3, :name=>'00', :parent_id=>6)], []], [[]], [[@c.load(:id=>5, :name=>'?', :parent_id=>4)]]]
     os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.children}}}.should == [[[[]], []], [[]], [[[]]]]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should eagerly load descendants when giving options" do
@@ -177,7 +177,7 @@ describe Sequel::Model, "rcte_tree" do
        {:i=>3, :name=>'00', :pi=>6, :kal=>6}, {:i=>3, :name=>'00', :pi=>6, :kal=>2},
        {:i=>4, :name=>'?', :pi=>7, :kal=>7}, {:i=>5, :name=>'?', :pi=>4, :kal=>7}]]
     os = @ds.eager(:ds).all
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\* FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\)\) SELECT \* FROM cte/
     os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D')]
@@ -187,7 +187,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.cs}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E')], [@c.load(:i=>3, :name=>'00', :pi=>6)], [@c.load(:i=>4, :name=>'?', :pi=>7)]]
     os.map{|o1| o1.cs.map{|o2| o2.cs}}.should == [[[@c.load(:i=>3, :name=>'00', :pi=>6)], []], [[]], [[@c.load(:i=>5, :name=>'?', :pi=>4)]]]
     os.map{|o1| o1.cs.map{|o2| o2.cs.map{|o3| o3.cs}}}.should == [[[[]], []], [[]], [[[]]]]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should eagerly load descendants to a given level" do
@@ -197,7 +197,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6, :x_level_x=>0}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2, :x_level_x=>1},
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7, :x_level_x=>0}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7, :x_level_x=>1}]]
     os = @ds.eager(:descendants=>2).all
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\*, 0 AS x_level_x FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\*, \(t\.x_level_x \+ 1\) AS x_level_x FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(t\.x_level_x < 1\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
@@ -207,7 +207,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.associations[:children]}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E')], [@c.load(:id=>3, :name=>'00', :parent_id=>6)], [@c.load(:id=>4, :name=>'?', :parent_id=>7)]]
     os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children]}}.should == [[[@c.load(:id=>3, :name=>'00', :parent_id=>6)], []], [[]], [[@c.load(:id=>5, :name=>'?', :parent_id=>4)]]]
     os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children].map{|o3| o3.associations[:children]}}}.should == [[[[]], []], [[]], [[nil]]]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should eagerly load descendants to a given level when giving options" do
@@ -217,7 +217,7 @@ describe Sequel::Model, "rcte_tree" do
        {:i=>3, :name=>'00', :pi=>6, :kal=>6, :lal=>0}, {:i=>3, :name=>'00', :pi=>6, :kal=>2, :lal=>1},
        {:i=>4, :name=>'?', :pi=>7, :kal=>7, :lal=>0}, {:i=>5, :name=>'?', :pi=>4, :kal=>7, :lal=>1}]]
     os = @ds.eager(:ds=>2).all
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\*, 0 AS lal FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\*, \(cte\.lal \+ 1\) AS lal FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\) WHERE \(cte\.lal < 1\)\) SELECT \* FROM cte/
     os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D')]
@@ -227,7 +227,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.associations[:cs]}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E')], [@c.load(:i=>3, :name=>'00', :pi=>6)], [@c.load(:i=>4, :name=>'?', :pi=>7)]]
     os.map{|o1| o1.associations[:cs].map{|o2| o2.associations[:cs]}}.should == [[[@c.load(:i=>3, :name=>'00', :pi=>6)], []], [[]], [[@c.load(:i=>5, :name=>'?', :pi=>4)]]]
     os.map{|o1| o1.associations[:cs].map{|o2| o2.associations[:cs].map{|o3| o3.associations[:cs]}}}.should == [[[[]], []], [[]], [[nil]]]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should eagerly load descendants respecting association option :conditions" do
@@ -237,7 +237,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2},
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]]
     @ds.eager(:descendants).all
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(parent_id IN \([267], [267], [267]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
   end