sequel 4.47.0 → 4.48.0

data/spec/extensions/meta_def_spec.rb

@@ -1,6 +1,15 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Metaprogramming" do
+  before do
+    deprecated do
+      Sequel.extension :meta_def
+    end
+  end
+  after do
+    Sequel::Metaprogramming.send(:remove_method, :meta_def)
+  end
+
   it "should add meta_def method to Database, Dataset, and Model classes and instances" do
     Sequel::Database.meta_def(:foo){1}
     Sequel::Database.foo.must_equal 1

data/spec/extensions/migration_spec.rb

@@ -429,13 +429,13 @@ describe "Sequel::IntegerMigrator" do
   end
 
   it "should use transactions by default if the database supports transactional ddl" do
-    @db.meta_def(:supports_transactional_ddl?){true}
+    def @db.supports_transactional_ddl?; true end
     Sequel::Migrator.apply(@db, "spec/files/transaction_unspecified_migrations")
     @db.sqls.must_equal ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2", "COMMIT"]
   end
 
   it "should respect transaction use on a per migration basis" do
-    @db.meta_def(:supports_transactional_ddl?){true}
+    def @db.supports_transactional_ddl?; true end
     Sequel::Migrator.apply(@db, "spec/files/transaction_specified_migrations")
     @db.sqls.must_equal ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "COMMIT", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2"]
   end
@@ -753,7 +753,7 @@ describe "Sequel::TimestampMigrator" do
   end
 
   it "should use transactions by default if database supports transactional ddl" do
-    @db.meta_def(:supports_transactional_ddl?){true}
+    def @db.supports_transactional_ddl?; true end
     Sequel::TimestampMigrator.apply(@db, "spec/files/transaction_unspecified_migrations")
     @db.sqls.must_equal ["SELECT NULL AS nil FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL AS nil FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')", "COMMIT"]
   end

data/spec/extensions/nested_attributes_spec.rb

@@ -462,7 +462,7 @@ describe "NestedAttributes plugin" do
     ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
   end
   
-  it "should not raise an Error if an unmatched primary key is given, if the :strict=>false option is used" do
+  deprecated "should not raise an Error if an unmatched primary key is given, if the :strict=>false option is used" do
     @Artist.nested_attributes :albums, :strict=>false
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
@@ -492,7 +492,7 @@ describe "NestedAttributes plugin" do
     ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :_delete=>'t'}])
   end
 
-  it "should not raise an Error if an unmatched composite primary key is given, if the :strict=>false option is used" do
+  deprecated "should not raise an Error if an unmatched composite primary key is given, if the :strict=>false option is used" do
     @Artist.nested_attributes :concerts, :strict=>false
     ar = @Artist.load(:id=>10, :name=>'Ar')
     co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
@@ -503,6 +503,17 @@ describe "NestedAttributes plugin" do
     @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 10)"]
   end
 
+  it "should not raise an Error if an unmatched composite primary key is given, if the :unmatched_pk=>:ignore option is used" do
+    @Artist.nested_attributes :concerts, :unmatched_pk=>:ignore
+    ar = @Artist.load(:id=>10, :name=>'Ar')
+    co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
+    ar.associations[:concerts] = [co]
+    ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-06', :_delete=>'t'}])
+    @db.sqls.must_equal []
+    ar.save
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 10)"]
+  end
+
   it "should not save if nested attribute is not valid and should include nested attribute validation errors in the main object's validation errors" do
     @Artist.class_eval do
       def validate
@@ -604,7 +615,7 @@ describe "NestedAttributes plugin" do
   end
 
   it "should return objects created/modified in the internal methods" do
-    @Album.nested_attributes :tags, :remove=>true, :strict=>false
+    @Album.nested_attributes :tags, :remove=>true, :unmatched_pk=>:ignore
     objs = []
     @Album.class_eval do
       define_method(:nested_attributes_create){|*a| objs << [super(*a), :create]}

data/spec/extensions/no_auto_literal_strings_spec.rb

@@ -9,9 +9,11 @@ describe "no_auto_literal_strings extension" do
     proc{@ds.where("a")}.must_raise Sequel::Error
     proc{@ds.having("a")}.must_raise Sequel::Error
     proc{@ds.filter("a")}.must_raise Sequel::Error
-    proc{@ds.exclude_where("a")}.must_raise Sequel::Error
     proc{@ds.exclude_having("a")}.must_raise Sequel::Error
-    proc{@ds.and("a")}.must_raise Sequel::Error
+    deprecated do
+      proc{@ds.exclude_where("a")}.must_raise Sequel::Error
+      proc{@ds.and("a")}.must_raise Sequel::Error
+    end
     proc{@ds.where(:a).or("a")}.must_raise Sequel::Error
     proc{@ds.first("a")}.must_raise Sequel::Error
     proc{@ds.order(:a).last("a")}.must_raise Sequel::Error
@@ -26,9 +28,11 @@ describe "no_auto_literal_strings extension" do
     @ds.where(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
     @ds.having(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t HAVING (a)'
     @ds.filter(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
-    @ds.exclude_where(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE NOT (a)'
     @ds.exclude_having(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t HAVING NOT (a)'
-    @ds.and(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
+    deprecated do
+      @ds.exclude_where(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE NOT (a)'
+      @ds.and(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
+    end
     @ds.where(:a).or(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a OR (a))'
     @ds.first(Sequel.lit("a"))
     @ds.order(:a).last(Sequel.lit("a"))

data/spec/extensions/pg_array_associations_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "pg_array_associations" do
   before do
-    @db = Sequel.mock(:numrows=>1)
+    @db = Sequel.mock(:host=>'postgres', :numrows=>1)
     @db.extend_datasets{def quote_identifiers?; false end}
     class ::Artist < Sequel::Model(@db)
       attr_accessor :yyy
@@ -71,7 +71,7 @@ describe Sequel::Model, "pg_array_associations" do
   end
 
   it "should allowing filtering by associations with :conditions" do
-    @c1.filter(:a_tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id = 2)))), 'f')"
+    @c1.filter(:a_tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id = 2)))), false)"
     @c2.filter(:a_artists=>@o1).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id = 1))))"
   end
 
@@ -81,7 +81,7 @@ describe Sequel::Model, "pg_array_associations" do
   end
 
   it "should allowing excluding by associations with :conditions" do
-    @c1.exclude(:a_tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id = 2)))), 'f') OR (artists.tag_ids IS NULL))"
+    @c1.exclude(:a_tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id = 2)))), false) OR (artists.tag_ids IS NULL))"
     @c2.exclude(:a_artists=>@o1).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id = 1)))) OR (tags.id IS NULL))"
   end
 
@@ -91,7 +91,7 @@ describe Sequel::Model, "pg_array_associations" do
   end
 
   it "should allowing filtering by multiple associations with :conditions" do
-    @c1.filter(:a_tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (1, 2))))), 'f')"
+    @c1.filter(:a_tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (1, 2))))), false)"
     @c2.filter(:a_artists=>[@c1.load(:id=>7, :tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:id=>8, :tag_ids=>Sequel.pg_array([4, 5]))]).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (7, 8)))))"
   end
 
@@ -101,40 +101,40 @@ describe Sequel::Model, "pg_array_associations" do
   end
 
   it "should allowing excluding by multiple associations with :conditions" do
-    @c1.exclude(:a_tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (1, 2))))), 'f') OR (artists.tag_ids IS NULL))"
+    @c1.exclude(:a_tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (1, 2))))), false) OR (artists.tag_ids IS NULL))"
     @c2.exclude(:a_artists=>[@c1.load(:id=>7, :tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:id=>8, :tag_ids=>Sequel.pg_array([4, 5]))]).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (7, 8))))) OR (tags.id IS NULL))"
   end
 
   it "should allowing filtering/excluding associations with NULL or empty values" do
-    @c1.filter(:tags=>@c2.new).sql.must_equal 'SELECT * FROM artists WHERE \'f\''
-    @c1.exclude(:tags=>@c2.new).sql.must_equal 'SELECT * FROM artists WHERE \'t\''
-    @c2.filter(:artists=>@c1.new).sql.must_equal 'SELECT * FROM tags WHERE \'f\''
-    @c2.exclude(:artists=>@c1.new).sql.must_equal 'SELECT * FROM tags WHERE \'t\''
+    @c1.filter(:tags=>@c2.new).sql.must_equal 'SELECT * FROM artists WHERE false'
+    @c1.exclude(:tags=>@c2.new).sql.must_equal 'SELECT * FROM artists WHERE true'
+    @c2.filter(:artists=>@c1.new).sql.must_equal 'SELECT * FROM tags WHERE false'
+    @c2.exclude(:artists=>@c1.new).sql.must_equal 'SELECT * FROM tags WHERE true'
 
-    @c2.filter(:artists=>@c1.load(:tag_ids=>[])).sql.must_equal 'SELECT * FROM tags WHERE \'f\''
-    @c2.exclude(:artists=>@c1.load(:tag_ids=>[])).sql.must_equal 'SELECT * FROM tags WHERE \'t\''
+    @c2.filter(:artists=>@c1.load(:tag_ids=>[])).sql.must_equal 'SELECT * FROM tags WHERE false'
+    @c2.exclude(:artists=>@c1.load(:tag_ids=>[])).sql.must_equal 'SELECT * FROM tags WHERE true'
 
     @c1.filter(:tags=>[@c2.new, @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"
     @c2.filter(:artists=>[@c1.load(:tag_ids=>Sequel.pg_array([3, 4])), @c1.new]).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (3, 4))"
   end
 
   it "should allowing filtering by association datasets" do
-    @c1.filter(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE (id = 1))), 'f')"
+    @c1.filter(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE (id = 1))), false)"
     @c2.filter(:artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE (id = 1)))"
   end
 
   it "should allowing filtering by association datasets with :conditions" do
-    @c1.filter(:a_tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (SELECT tags.id FROM tags WHERE (id = 1)))))), 'f')"
+    @c1.filter(:a_tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (SELECT tags.id FROM tags WHERE (id = 1)))))), false)"
     @c2.filter(:a_artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (SELECT artists.id FROM artists WHERE (id = 1))))))"
   end
 
   it "should allowing excluding by association datasets" do
-    @c1.exclude(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE (id = 1))), 'f') OR (artists.tag_ids IS NULL))"
+    @c1.exclude(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE (id = 1))), false) OR (artists.tag_ids IS NULL))"
     @c2.exclude(:artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE (id = 1))) OR (tags.id IS NULL))"
   end
 
   it "should allowing excluding by association datasets with :conditions" do
-    @c1.exclude(:a_tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (SELECT tags.id FROM tags WHERE (id = 1)))))), 'f') OR (artists.tag_ids IS NULL))"
+    @c1.exclude(:a_tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (SELECT tags.id FROM tags WHERE (id = 1)))))), false) OR (artists.tag_ids IS NULL))"
     @c2.exclude(:a_artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (SELECT artists.id FROM artists WHERE (id = 1)))))) OR (tags.id IS NULL))"
   end
 
@@ -145,7 +145,7 @@ describe Sequel::Model, "pg_array_associations" do
 
     @c1.filter(:tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids[1:2] @> ARRAY[6]::integer[])"
     @c2.filter(:artists=>@o1).sql.must_equal "SELECT * FROM tags WHERE ((tags.id * 3) IN (3, 6, 9))"
-    @c1.filter(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids[1:2] && (SELECT array_agg((tags.id * 3)) FROM tags WHERE (id = 1))), 'f')"
+    @c1.filter(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids[1:2] && (SELECT array_agg((tags.id * 3)) FROM tags WHERE (id = 1))), false)"
     @c2.filter(:artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE ((tags.id * 3) IN (SELECT unnest(artists.tag_ids[1:2]) FROM artists WHERE (id = 1)))"
   end
   
@@ -315,6 +315,7 @@ describe Sequel::Model, "pg_array_associations" do
 
     @c2.dataset = @c2.dataset.with_fetch(:id=>2, :artists_id=>1, :tag_ids=>Sequel.pg_array([1,2,3]))
     @c1.dataset = @c1.dataset.with_fetch(:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3]))
+    @db.sqls
 
     @o1.tags2.must_equal [@o2]
     @db.sqls.first.must_match(/SELECT tags\.id, artists\.id AS artists_id, artists\.tag_ids FROM tags LEFT OUTER JOIN artists ON \(artists.tag_ids @> ARRAY\[tags.id\]\) WHERE \(tags\.id IN \([123], [123], [123]\)\)/)
@@ -328,6 +329,7 @@ describe Sequel::Model, "pg_array_associations" do
 
     @c2.dataset = @c2.dataset.with_fetch(:id=>2, :artists_id=>1, :tag_ids=>Sequel.pg_array([1,2,3]))
     @c1.dataset = @c1.dataset.with_fetch(:id=>1, :tag_ids=>Sequel.pg_array([1,2,3]))
+    @db.sqls
 
     a = @c1.eager(:tags2).all
     sqls = @db.sqls
@@ -340,6 +342,7 @@ describe Sequel::Model, "pg_array_associations" do
 
     @c2.dataset = @c2.dataset.with_fetch(:id=>2)
     @c1.dataset = @c1.dataset.with_fetch(:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3]))
+    @db.sqls
 
     a = @c2.eager(:artists2).all
     @db.sqls.must_equal ["SELECT * FROM tags", "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id]) WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
@@ -351,6 +354,7 @@ describe Sequel::Model, "pg_array_associations" do
   
   it "should respect the :limit option when eager loading" do
     @c2.dataset = @c2.dataset.with_fetch([{:id=>1},{:id=>2}, {:id=>3}])
+    @db.sqls
 
     @c1.pg_array_to_many :tags, :clone=>:tags, :limit=>2
     a = @c1.eager(:tags).all
@@ -381,6 +385,7 @@ describe Sequel::Model, "pg_array_associations" do
 
     @c2.dataset = @c2.dataset.with_fetch(:id=>2)
     @c1.dataset = @c1.dataset.with_fetch([{:id=>5, :tag_ids=>Sequel.pg_array([1,2,3])},{:id=>6, :tag_ids=>Sequel.pg_array([2,3])}, {:id=>7, :tag_ids=>Sequel.pg_array([1,2])}])
+    @db.sqls
 
     @c2.many_to_pg_array :artists, :clone=>:artists, :limit=>2
     a = @c2.eager(:artists).all
@@ -417,6 +422,7 @@ describe Sequel::Model, "pg_array_associations" do
   it "should eagerly graph associations" do
     @c2.dataset = @c2.dataset.with_fetch(:id=>2, :artists_id=>1, :tag_ids=>Sequel.pg_array([1,2,3]))
     @c1.dataset = @c1.dataset.with_fetch(:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3]))
+    @db.sqls
 
     a = @c1.eager_graph(:tags).all
     @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"]
@@ -434,6 +440,7 @@ describe Sequel::Model, "pg_array_associations" do
   it "should allow cascading of eager graphing for associations of associated models" do
     @c2.dataset = @c2.dataset.with_fetch(:id=>2, :artists_id=>1, :tag_ids=>Sequel.pg_array([1,2,3]), :tags_0_id=>2)
     @c1.dataset = @c1.dataset.with_fetch(:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3]), :artists_0_id=>1, :artists_0_tag_ids=>Sequel.pg_array([1,2,3]))
+    @db.sqls
 
     a = @c1.eager_graph(:tags=>:artists).all
     @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id, artists_0.id AS artists_0_id, artists_0.tag_ids AS artists_0_tag_ids FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id]) LEFT OUTER JOIN artists AS artists_0 ON (artists_0.tag_ids @> ARRAY[tags.id])"]
@@ -457,6 +464,7 @@ describe Sequel::Model, "pg_array_associations" do
 
     @c2.dataset = @c2.dataset.with_fetch(:id=>2, :artists_id=>1, :tag_ids=>Sequel.pg_array([1,2,3]), :tags_0_id=>2)
     @c1.dataset = @c1.dataset.with_fetch(:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3]), :artists_0_id=>1, :artists_0_tag_ids=>Sequel.pg_array([1,2,3]))
+    @db.sqls
 
     a = @c1.eager_graph(:tags).all
     a.must_equal [@o1]
@@ -477,6 +485,7 @@ describe Sequel::Model, "pg_array_associations" do
 
     @c2.dataset = @c2.dataset.with_fetch(:id=>2, :artists_id=>1)
     @c1.dataset = @c1.dataset.with_fetch(:id=>1, :id2=>2, :tag_ids=>Sequel.pg_array([1,2,3]))
+    @db.sqls
 
     a = @c1.eager_graph(:tags).all
     @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id2 FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"]
@@ -738,15 +747,17 @@ end
 
 describe "Sequel::Model.finalize_associations" do
   before do
-    class ::Foo < Sequel::Model
+    @db = Sequel.mock(:host=>'postgres', :numrows=>1)
+    class ::Foo < Sequel::Model(@db)
       plugin :pg_array_associations
       many_to_pg_array :items
     end
-    class ::Item < Sequel::Model
+    class ::Item < Sequel::Model(@db)
       plugin :pg_array_associations
       pg_array_to_many :foos
     end
     [Foo, Item].each(&:finalize_associations)
+    @db.sqls
   end
   after do
     Object.send(:remove_const, :Item)

data/spec/extensions/pg_array_spec.rb

@@ -3,10 +3,10 @@ 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_types = Sequel::Postgres::PG__TYPES.dup # SEQUEL5: Remove
   end
   after(:all) do
-    Sequel::Postgres::PG_TYPES.replace(@pg_types)
+    Sequel::Postgres::PG__TYPES.replace(@pg_types) # SEQUEL5: Remove
   end
 
   before do
@@ -18,7 +18,7 @@ describe "pg_array extension" do
     end)
     @db.extension(:pg_array)
     @m = Sequel::Postgres
-    @converter = @m::PG_TYPES
+    @converter = @db.conversion_procs
     @db.sqls
   end
 
@@ -34,6 +34,11 @@ describe "pg_array extension" do
     c.call('{a,b}').to_a.must_equal ['a', 'b']
   end
 
+  it "should preserve encoding when parsing text arrays" do
+    c = @converter[1009]
+    c.call("{a,\u00E4}".encode('ISO-8859-1')).map(&:encoding).must_equal [Encoding::ISO_8859_1, Encoding::ISO_8859_1]
+  end if RUBY_VERSION >= '1.9'
+
   it "should parse multi-dimensional text arrays" do
     c = @converter[1009]
     c.call("{{}}").to_a.must_equal [[]]
@@ -256,42 +261,53 @@ describe "pg_array extension" do
     @db.select(Sequel.pg_array([1], :integer).as(:col1)).sql.must_equal 'SELECT ARRAY[1]::integer[] AS col1'
   end
 
-  it "should support registering custom array types" do
+  deprecated "should support registering custom array types" do
     Sequel::Postgres::PGArray.register('foo')
     @db.typecast_value(:foo_array, []).class.must_equal(Sequel::Postgres::PGArray)
     @db.fetch = [{:name=>'id', :db_type=>'foo[]'}]
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:foo_array]
   end
 
+  deprecated "should raise error if register given convertor option and block" do
+    proc{Sequel::Postgres::PGArray.register('foo', :converter=>:to_s.to_proc, &:to_s)}.must_raise Sequel::Error
+  end
+
+  it "should support registering custom array types" do
+    @db.register_array_type('foo')
+    @db.typecast_value(:foo_array, []).class.must_equal(Sequel::Postgres::PGArray)
+    @db.fetch = [{:name=>'id', :db_type=>'foo[]'}]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:foo_array]
+  end
+
   it "should support registering custom types with :type_symbol option" do
-    Sequel::Postgres::PGArray.register('foo', :type_symbol=>:bar)
+    @db.register_array_type('foo', :type_symbol=>:bar)
     @db.typecast_value(:bar_array, []).class.must_equal(Sequel::Postgres::PGArray)
     @db.fetch = [{:name=>'id', :db_type=>'foo[]'}]
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:bar_array]
   end
 
   it "should support using a block as a custom conversion proc given as block" do
-    Sequel::Postgres::PGArray.register('foo', :oid=>1234){|s| (s*2).to_i}
-    @converter[1234].call('{1}').must_equal [11]
+    @db.register_array_type('foo', :oid=>1234){|s| (s*2).to_i}
+    @db.conversion_procs[1234].call('{1}').must_equal [11]
   end
 
   it "should support using a block as a custom conversion proc given as :converter option" do
-    Sequel::Postgres::PGArray.register('foo', :oid=>1234, :converter=>proc{|s| (s*2).to_i})
-    @converter[1234].call('{1}').must_equal [11]
+    @db.register_array_type('foo', :oid=>1234, :converter=>proc{|s| (s*2).to_i})
+    @db.conversion_procs[1234].call('{1}').must_equal [11]
   end
 
   it "should support using an existing scaler conversion proc via the :scalar_oid option" do
-    Sequel::Postgres::PGArray.register('foo', :oid=>1234, :scalar_oid=>16)
-    @converter[1234].call('{t}').must_equal [true]
+    @db.register_array_type('foo', :oid=>1234, :scalar_oid=>16)
+    @db.conversion_procs[1234].call('{t}').must_equal [true]
   end
 
-  it "should support using a given conversion procs hash via the :type_procs option" do
+  deprecated "should support using a given conversion procs hash via the :type_procs option" do
     h = {16=>proc{|s| "!#{s}"}}
     Sequel::Postgres::PGArray.register('foo', :oid=>1234, :scalar_oid=>16, :type_procs=>h)
     h[1234].call('{t}').must_equal ["!t"]
   end
 
-  it "should support adding methods to the given module via the :typecast_methods_module option" do
+  deprecated "should support adding methods to the given module via the :typecast_methods_module option" do
     m = Module.new
     Sequel::Postgres::PGArray.register('foo15', :scalar_typecast=>:boolean, :typecast_methods_module=>m)
     @db.typecast_value(:foo15_array, ['t']).must_equal ['t']
@@ -300,32 +316,31 @@ describe "pg_array extension" do
   end
 
   it "should not raise an error if using :scalar_oid option with unexisting scalar conversion proc" do
-    h = {}
-    Sequel::Postgres::PGArray.register('foo', :oid=>1234, :scalar_oid=>0, :type_procs=>h)
-    h[1234].call('{t}').must_equal ["t"]
+    @db.register_array_type('foo', :oid=>1234, :scalar_oid=>0)
+    @db.conversion_procs[1234].call('{t}').must_equal ["t"]
   end
 
   it "should raise an error if using :converter option and a block argument" do
-    proc{Sequel::Postgres::PGArray.register('foo', :converter=>proc{}){}}.must_raise(Sequel::Error)
+    proc{@db.register_array_type('foo', :converter=>proc{}){}}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if using :scalar_oid option and a block argument" do
-    proc{Sequel::Postgres::PGArray.register('foo', :scalar_oid=>16){}}.must_raise(Sequel::Error)
+    proc{@db.register_array_type('foo', :scalar_oid=>16){}}.must_raise(Sequel::Error)
   end
 
   it "should support registering custom types with :oid option" do
-    Sequel::Postgres::PGArray.register('foo', :oid=>1)
-    Sequel::Postgres::PG_TYPES[1].call('{1}').class.must_equal(Sequel::Postgres::PGArray)
+    @db.register_array_type('foo', :oid=>1)
+    @db.conversion_procs[1].call('{1}').class.must_equal(Sequel::Postgres::PGArray)
   end
 
   it "should support registering converters with blocks" do
-    Sequel::Postgres::PGArray.register('foo', :oid=>4){|s| s.to_i * 2}
-    Sequel::Postgres::PG_TYPES[4].call('{{1,2},{3,4}}').must_equal [[2, 4], [6, 8]]
+    @db.register_array_type('foo', :oid=>4){|s| s.to_i * 2}
+    @db.conversion_procs[4].call('{{1,2},{3,4}}').must_equal [[2, 4], [6, 8]]
   end
 
   it "should support registering custom types with :array_type option" do
-    Sequel::Postgres::PGArray.register('foo', :oid=>3, :array_type=>:blah)
-    @db.literal(Sequel::Postgres::PG_TYPES[3].call('{}')).must_equal "'{}'::blah[]"
+    @db.register_array_type('foo', :oid=>3, :array_type=>:blah)
+    @db.literal(@db.conversion_procs[3].call('{}')).must_equal "'{}'::blah[]"
   end
 
   it "should not support registering custom array types on a per-Database basis for frozen databases" do
@@ -373,9 +388,13 @@ describe "pg_array extension" do
     @db.typecast_value(:banana_array, %w'1 2').must_equal [1,2]
   end
 
+  it "should set appropriate timestamp conversion procs" do
+    @db.conversion_procs[1185].call('{"2011-10-20 11:12:13"}').must_equal [Time.local(2011, 10, 20, 11, 12, 13)]
+    @db.conversion_procs[1115].call('{"2011-10-20 11:12:13"}').must_equal [Time.local(2011, 10, 20, 11, 12, 13)]
+  end
+
   it "should set appropriate timestamp conversion procs when adding conversion procs" do
     @db.fetch = [[{:oid=>2222, :typname=>'foo'}], [{:oid=>2222, :typarray=>2223, :typname=>'foo'}]]
-    @db.reset_conversion_procs
     @db.add_named_conversion_proc(:foo){|v| v*2}
     procs = @db.conversion_procs
     procs[1185].call('{"2011-10-20 11:12:13"}').must_equal [Time.local(2011, 10, 20, 11, 12, 13)]

data/spec/extensions/pg_hstore_spec.rb

@@ -7,6 +7,7 @@ describe "pg_hstore extension" do
     @db.extend_datasets{def quote_identifiers?; false end}
     @m = Sequel::Postgres
     @c = @m::HStore
+    @db.fetch = {:oid=>9999, :typname=>'hstore'}
     @db.extension :pg_hstore
   end
 
@@ -34,6 +35,15 @@ describe "pg_hstore extension" do
     ['\'"a"=>"b","c"=>"d"\'::hstore', '\'"c"=>"d","a"=>"b"\'::hstore'].must_include(@db.literal(Sequel.hstore("a"=>"b","c"=>"d")))
   end
 
+  it "should register conversion proc correctly" do
+    @db.conversion_procs[9999].call('"a"=>"b"').must_equal('a'=>'b')
+  end
+
+  deprecated "should reregister conversion proc when resetting conversion procs" do
+    @db.reset_conversion_procs
+    @db.conversion_procs[9999].call('"a"=>"b"').must_equal('a'=>'b')
+  end
+
   it "should have Sequel.hstore method for creating HStore instances" do
     Sequel.hstore({}).class.must_equal(@c)
   end