sequel 3.44.0 → 3.45.0

data/spec/extensions/constraint_validations_spec.rb

@@ -240,14 +240,14 @@ describe "constraint_validations extension" do
     @db.create_table(:foo){String :name; validate{like 'foo%', :name}}
     sqls = @db.sqls
     parse_insert(sqls.slice!(1)).should == {:validation_type=>"like", :column=>"name", :table=>"foo", :argument=>'foo%'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name LIKE 'foo%')))"]
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name LIKE 'foo%' ESCAPE '\\')))"]
   end
 
   it "should support :ilike constraint validation" do
     @db.create_table(:foo){String :name; validate{ilike 'foo%', :name}}
     sqls = @db.sqls
     parse_insert(sqls.slice!(1)).should == {:validation_type=>"ilike", :column=>"name", :table=>"foo", :argument=>'foo%'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name ILIKE 'foo%')))"]
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (UPPER(name) LIKE UPPER('foo%') ESCAPE '\\')))"]
   end
 
   it "should support :unique constraint validation" do

data/spec/extensions/core_refinements_spec.rb

@@ -69,35 +69,35 @@ describe "Core refinements" do
   end
   
   it "should support LIKE via Symbol#like" do
-    @d.l(:x.like('a')).should == '(x LIKE \'a\')'
+    @d.l(:x.like('a')).should == '(x LIKE \'a\' ESCAPE \'\\\')'
     @d.l(:x.like(/a/)).should == '(x ~ \'a\')'
-    @d.l(:x.like('a', 'b')).should == '((x LIKE \'a\') OR (x LIKE \'b\'))'
+    @d.l(:x.like('a', 'b')).should == '((x LIKE \'a\' ESCAPE \'\\\') OR (x LIKE \'b\' ESCAPE \'\\\'))'
     @d.l(:x.like(/a/, /b/i)).should == '((x ~ \'a\') OR (x ~* \'b\'))'
-    @d.l(:x.like('a', /b/)).should == '((x LIKE \'a\') OR (x ~ \'b\'))'
+    @d.l(:x.like('a', /b/)).should == '((x LIKE \'a\' ESCAPE \'\\\') OR (x ~ \'b\'))'
   end
 
   it "should support NOT LIKE via Symbol#like and Symbol#~" do
-    @d.l(~:x.like('a')).should == '(x NOT LIKE \'a\')'
+    @d.l(~:x.like('a')).should == '(x NOT LIKE \'a\' ESCAPE \'\\\')'
     @d.l(~:x.like(/a/)).should == '(x !~ \'a\')'
-    @d.l(~:x.like('a', 'b')).should == '((x NOT LIKE \'a\') AND (x NOT LIKE \'b\'))'
+    @d.l(~:x.like('a', 'b')).should == '((x NOT LIKE \'a\' ESCAPE \'\\\') AND (x NOT LIKE \'b\' ESCAPE \'\\\'))'
     @d.l(~:x.like(/a/, /b/i)).should == '((x !~ \'a\') AND (x !~* \'b\'))'
-    @d.l(~:x.like('a', /b/)).should == '((x NOT LIKE \'a\') AND (x !~ \'b\'))'
+    @d.l(~:x.like('a', /b/)).should == '((x NOT LIKE \'a\' ESCAPE \'\\\') AND (x !~ \'b\'))'
   end
 
   it "should support ILIKE via Symbol#ilike" do
-    @d.l(:x.ilike('a')).should == '(x ILIKE \'a\')'
+    @d.l(:x.ilike('a')).should == '(UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\')'
     @d.l(:x.ilike(/a/)).should == '(x ~* \'a\')'
-    @d.l(:x.ilike('a', 'b')).should == '((x ILIKE \'a\') OR (x ILIKE \'b\'))'
+    @d.l(:x.ilike('a', 'b')).should == '((UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\') OR (UPPER(x) LIKE UPPER(\'b\') ESCAPE \'\\\'))'
     @d.l(:x.ilike(/a/, /b/i)).should == '((x ~* \'a\') OR (x ~* \'b\'))'
-    @d.l(:x.ilike('a', /b/)).should == '((x ILIKE \'a\') OR (x ~* \'b\'))'
+    @d.l(:x.ilike('a', /b/)).should == '((UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\') OR (x ~* \'b\'))'
   end
 
   it "should support NOT ILIKE via Symbol#ilike and Symbol#~" do
-    @d.l(~:x.ilike('a')).should == '(x NOT ILIKE \'a\')'
+    @d.l(~:x.ilike('a')).should == '(UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\')'
     @d.l(~:x.ilike(/a/)).should == '(x !~* \'a\')'
-    @d.l(~:x.ilike('a', 'b')).should == '((x NOT ILIKE \'a\') AND (x NOT ILIKE \'b\'))'
+    @d.l(~:x.ilike('a', 'b')).should == '((UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\') AND (UPPER(x) NOT LIKE UPPER(\'b\') ESCAPE \'\\\'))'
     @d.l(~:x.ilike(/a/, /b/i)).should == '((x !~* \'a\') AND (x !~* \'b\'))'
-    @d.l(~:x.ilike('a', /b/)).should == '((x NOT ILIKE \'a\') AND (x !~* \'b\'))'
+    @d.l(~:x.ilike('a', /b/)).should == '((UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\') AND (x !~* \'b\'))'
   end
 
   it "should support sql_expr on arrays with all two pairs" do

data/spec/extensions/json_serializer_spec.rb

@@ -3,12 +3,15 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "Sequel::Plugins::JsonSerializer" do
   before do
     class ::Artist < Sequel::Model
+      unrestrict_primary_key
       plugin :json_serializer
       columns :id, :name
       def_column_accessor :id, :name
+      @db_schema = {:id=>{:type=>:integer}}
       one_to_many :albums
     end
     class ::Album < Sequel::Model
+      unrestrict_primary_key
       attr_accessor :blah
       plugin :json_serializer
       columns :id, :name, :artist_id
@@ -27,8 +30,8 @@ describe "Sequel::Plugins::JsonSerializer" do
   end
 
   it "should round trip successfully" do
-    JSON.parse(@artist.to_json).should == @artist
-    JSON.parse(@album.to_json).should == @album
+    Artist.from_json(@artist.to_json).should == @artist
+    Album.from_json(@album.to_json).should == @album
   end
 
   it "should handle ruby objects in values" do
@@ -37,52 +40,106 @@ describe "Sequel::Plugins::JsonSerializer" do
         super(Date.parse(v))
       end
     end
-    JSON.parse(Artist.load(:name=>Date.today).to_json).should == Artist.load(:name=>Date.today)
+    Artist.from_json(Artist.load(:name=>Date.today).to_json).should == Artist.load(:name=>Date.today)
+  end
+
+  it "should have .json_create method for creating an instance from a hash parsed from JSON" do
+    JSON.parse(@artist.to_json, :create_additions=>true).should == @artist
+    JSON.parse(@artist.to_json(:include=>{:albums=>{:include=>{:artist=>{:include=>:albums}}}}), :create_additions=>true).albums.map{|a| a.artist.albums}.should == [[@album]]
+  end
+
+  it "should have .json_create method raise error if not given a hash" do
+    proc{Artist.json_create([])}.should raise_error(Sequel::Error)
   end
 
   it "should handle the :only option" do
-    JSON.parse(@artist.to_json(:only=>:name)).should == Artist.load(:name=>@artist.name)
-    JSON.parse(@album.to_json(:only=>[:id, :name])).should == Album.load(:id=>@album.id, :name=>@album.name)
+    Artist.from_json(@artist.to_json(:only=>:name)).should == Artist.load(:name=>@artist.name)
+    Album.from_json(@album.to_json(:only=>[:id, :name])).should == Album.load(:id=>@album.id, :name=>@album.name)
   end
 
   it "should handle the :except option" do
-    JSON.parse(@artist.to_json(:except=>:id)).should == Artist.load(:name=>@artist.name)
-    JSON.parse(@album.to_json(:except=>[:id, :artist_id])).should == Album.load(:name=>@album.name)
+    Artist.from_json(@artist.to_json(:except=>:id)).should == Artist.load(:name=>@artist.name)
+    Album.from_json(@album.to_json(:except=>[:id, :artist_id])).should == Album.load(:name=>@album.name)
   end
 
   it "should handle the :include option for associations" do
-    JSON.parse(@artist.to_json(:include=>:albums)).albums.should == [@album]
-    JSON.parse(@album.to_json(:include=>:artist)).artist.should == @artist
+    Artist.from_json(@artist.to_json(:include=>:albums), :associations=>:albums).albums.should == [@album]
+    Album.from_json(@album.to_json(:include=>:artist), :associations=>:artist).artist.should == @artist
+  end
+
+  it "should raise an error if attempting to parse json when providing array to non-array association or vice-versa" do
+    proc{Artist.from_json('{"albums":{"id":1,"name":"RF","artist_id":2,"json_class":"Album"},"id":2,"name":"YJM","json_class":"Artist"}', :associations=>:albums)}.should raise_error(Sequel::Error)
+    proc{Album.from_json('{"artist":[{"id":2,"name":"YJM","json_class":"Artist"}],"id":1,"name":"RF","json_class":"Album","artist_id":2}', :associations=>:artist)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempting to parse an array containing non-hashes" do
+    proc{Artist.from_json('[{"id":2,"name":"YJM","json_class":"Artist"}, 2]')}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempting to parse invalid JSON" do
+    begin
+      Sequel.instance_eval do
+        alias pj parse_json
+        def parse_json(v)
+          v
+        end
+      end
+      proc{Album.from_json('1')}.should raise_error(Sequel::Error)
+    ensure
+      Sequel.instance_eval do
+        alias parse_json pj
+      end
+    end
+  end
+
+  it "should handle case where Sequel.parse_json already returns an instance" do
+    begin
+      Sequel.instance_eval do
+        alias pj parse_json
+        def parse_json(v)
+          Album.load(:id=>3)
+        end
+      end
+      ::Album.from_json('1').should == Album.load(:id=>3)
+    ensure
+      Sequel.instance_eval do
+        alias parse_json pj
+      end
+    end
   end
 
   it "should handle the :include option for arbitrary attributes" do
-    JSON.parse(@album.to_json(:include=>:blah)).blah.should == @album.blah
+    Album.from_json(@album.to_json(:include=>:blah)).blah.should == @album.blah
   end
 
   it "should handle multiple inclusions using an array for the :include option" do
-    a = JSON.parse(@album.to_json(:include=>[:blah, :artist]))
+    a = Album.from_json(@album.to_json(:include=>[:blah, :artist]), :associations=>:artist)
     a.blah.should == @album.blah
     a.artist.should == @artist
   end
 
   it "should handle cascading using a hash for the :include option" do
-    JSON.parse(@artist.to_json(:include=>{:albums=>{:include=>:artist}})).albums.map{|a| a.artist}.should == [@artist]
-    JSON.parse(@album.to_json(:include=>{:artist=>{:include=>:albums}})).artist.albums.should == [@album]
+    Artist.from_json(@artist.to_json(:include=>{:albums=>{:include=>:artist}}), :associations=>{:albums=>{:associations=>:artist}}).albums.map{|a| a.artist}.should == [@artist]
+    Album.from_json(@album.to_json(:include=>{:artist=>{:include=>:albums}}), :associations=>{:artist=>{:associations=>:albums}}).artist.albums.should == [@album]
 
-    JSON.parse(@artist.to_json(:include=>{:albums=>{:only=>:name}})).albums.should == [Album.load(:name=>@album.name)]
-    JSON.parse(@album.to_json(:include=>{:artist=>{:except=>:name}})).artist.should == Artist.load(:id=>@artist.id)
+    Artist.from_json(@artist.to_json(:include=>{:albums=>{:only=>:name}}), :associations=>[:albums]).albums.should == [Album.load(:name=>@album.name)]
+    Album.from_json(@album.to_json(:include=>{:artist=>{:except=>:name}}), :associations=>[:artist]).artist.should == Artist.load(:id=>@artist.id)
 
-    JSON.parse(@artist.to_json(:include=>{:albums=>{:include=>{:artist=>{:include=>:albums}}}})).albums.map{|a| a.artist.albums}.should == [[@album]]
-    JSON.parse(@album.to_json(:include=>{:artist=>{:include=>{:albums=>{:only=>:name}}}})).artist.albums.should == [Album.load(:name=>@album.name)]
+    Artist.from_json(@artist.to_json(:include=>{:albums=>{:include=>{:artist=>{:include=>:albums}}}}), :associations=>{:albums=>{:associations=>{:artist=>{:associations=>:albums}}}}).albums.map{|a| a.artist.albums}.should == [[@album]]
+    Album.from_json(@album.to_json(:include=>{:artist=>{:include=>{:albums=>{:only=>:name}}}}), :associations=>{:artist=>{:associations=>:albums}}).artist.albums.should == [Album.load(:name=>@album.name)]
+  end
+
+  it "should automatically cascade parsing for all associations if :all_associations is used" do
+    Artist.from_json(@artist.to_json(:include=>{:albums=>{:include=>:artist}}), :all_associations=>true).albums.map{|a| a.artist}.should == [@artist]
   end
 
   it "should handle the :include option cascading with an empty hash" do
-    JSON.parse(@album.to_json(:include=>{:artist=>{}})).artist.should == @artist
-    JSON.parse(@album.to_json(:include=>{:blah=>{}})).blah.should == @album.blah
+    Album.from_json(@album.to_json(:include=>{:artist=>{}}), :associations=>:artist).artist.should == @artist
+    Album.from_json(@album.to_json(:include=>{:blah=>{}})).blah.should == @album.blah
   end
 
   it "should accept a :naked option to not include the JSON.create_id, so parsing yields a plain hash" do
-    JSON.parse(@album.to_json(:naked=>true)).should == @album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}
+    Sequel.parse_json(@album.to_json(:naked=>true)).should == @album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}
   end
 
   it "should support #from_json to set column values" do
@@ -107,35 +164,39 @@ describe "Sequel::Plugins::JsonSerializer" do
     proc{@album.from_json('{"artist_id": 3}', :fields=>['name'], :missing=>:raise)}.should raise_error(Sequel::Error)
   end
 
+  it "should have #from_json raise an error if parsed json isn't a hash" do
+    proc{@artist.from_json('[]')}.should raise_error(Sequel::Error)
+  end
+
   it "should raise an exception for json keys that aren't associations, columns, or setter methods" do
     Album.send(:undef_method, :blah=)
-    proc{JSON.parse(@album.to_json(:include=>:blah))}.should raise_error(Sequel::Error)
+    proc{Album.from_json(@album.to_json(:include=>:blah))}.should raise_error(Sequel::Error)
   end
 
   it "should support a to_json class and dataset method" do
     Album.dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
     Artist.dataset._fetch = {:id=>2, :name=>'YJM'}
-    JSON.parse(Album.to_json).should == [@album]
-    JSON.parse(Album.to_json(:include=>:artist)).map{|x| x.artist}.should == [@artist]
-    JSON.parse(Album.dataset.to_json(:only=>:name)).should == [Album.load(:name=>@album.name)]
+    Album.array_from_json(Album.to_json).should == [@album]
+    Album.array_from_json(Album.to_json(:include=>:artist), :associations=>:artist).map{|x| x.artist}.should == [@artist]
+    Album.array_from_json(Album.dataset.to_json(:only=>:name)).should == [Album.load(:name=>@album.name)]
   end
 
   it "should have dataset to_json method work with naked datasets" do
     album = @album
     ds = Album.dataset.naked
     ds._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
-    JSON.parse(ds.to_json).should == [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]
+    Sequel.parse_json(ds.to_json).should == [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]
   end
 
   it "should have dataset to_json method respect :array option for the array to use" do
-    a = Album.load(:id=>1, :name=>'RF', :artist_id=>3)
-    JSON.parse(Album.to_json(:array=>[a])).should == [a]
+    a = Album.new(:name=>'RF', :artist_id=>3)
+    Album.array_from_json(Album.to_json(:array=>[a])).should == [a]
 
     a.associations[:artist] = artist = Artist.load(:id=>3, :name=>'YJM')
-    JSON.parse(Album.to_json(:array=>[a], :include=>:artist)).first.artist.should == artist
+    Album.array_from_json(Album.to_json(:array=>[a], :include=>:artist), :associations=>:artist).first.artist.should == artist
 
     artist.associations[:albums] = [a]
-    x = JSON.parse(Artist.to_json(:array=>[artist], :include=>:albums))
+    x = Artist.array_from_json(Artist.to_json(:array=>[artist], :include=>:albums), :associations=>[:albums])
     x.should == [artist]
     x.first.albums.should == [a]
   end
@@ -191,12 +252,57 @@ describe "Sequel::Plugins::JsonSerializer" do
     class ::Artist2 < Artist
       plugin :json_serializer, :only=>:name
     end
-    JSON.parse(Artist2.load(:id=>2, :name=>'YYY').to_json).should == Artist2.load(:name=>'YYY')
+    Artist2.from_json(Artist2.load(:id=>2, :name=>'YYY').to_json).should == Artist2.load(:name=>'YYY')
     class ::Artist3 < Artist2
       plugin :json_serializer, :naked=>:true
     end
-    JSON.parse(Artist3.load(:id=>2, :name=>'YYY').to_json).should == {"name"=>'YYY'}
+    Sequel.parse_json(Artist3.load(:id=>2, :name=>'YYY').to_json).should == {"name"=>'YYY'}
     Object.send(:remove_const, :Artist2)
     Object.send(:remove_const, :Artist3)
   end
+
+  it "should have :associations option take precedence over :all_assocations" do
+    Artist.from_json(@artist.to_json(:include=>:albums), :associations=>[], :all_associations=>true, :fields=>[]).associations.should == {}
+  end
+
+  it "should allow overriding of :all_columns options in associated objects" do
+    Album.restrict_primary_key
+    Artist.from_json(@artist.to_json(:include=>:albums), :associations=>{:albums=>{:fields=>[:id, :name, :artist_id], :missing=>:raise}}, :all_columns=>true).albums.should == [@album]
+  end
+
+  it "should handle typecasting if setter columns exist when using :all_columns" do
+    Artist.restrict_primary_key
+    Artist.from_json('{"id":"2","name":"YJM","json_class":"Artist"}', :all_columns=>true).should == @artist
+  end
+
+  it "should allow setting columns that are restricted if :all_columns is used" do
+    Artist.restrict_primary_key
+    Artist.from_json(@artist.to_json, :all_columns=>true).should == @artist
+  end
+
+  it "should raise an error if using :all_columns and non-column is in the JSON" do
+    proc{Artist.from_json('{"foo":"bar"}', :all_columns=>true)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempting to set a restricted column and :all_columns is not used" do
+    Artist.restrict_primary_key
+    proc{Artist.from_json(@artist.to_json)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if an unsupported association is passed in the :associations option" do
+    Artist.association_reflections.delete(:albums)
+    proc{Artist.from_json(@artist.to_json(:include=>:albums), :associations=>:albums)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if using from_json and JSON parsing returns an array" do
+    proc{Artist.from_json([@artist].to_json)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if using array_from_json and JSON parsing does not return an array" do
+    proc{Artist.array_from_json(@artist.to_json)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if using an unsupported :associations option" do
+    proc{Artist.from_json(@artist.to_json, :associations=>'')}.should raise_error(Sequel::Error)
+  end
 end

data/spec/extensions/named_timezones_spec.rb

@@ -19,6 +19,7 @@ describe "Sequel named_timezones extension" do
     Sequel.datetime_class = DateTime
   end
   after do
+    Sequel.tzinfo_disambiguator = nil
     Sequel.default_timezone = nil
     Sequel.datetime_class = Time
   end
@@ -53,6 +54,15 @@ describe "Sequel named_timezones extension" do
     dt.offset.should == -7/24.0
   end
     
+  it "should raise an error for ambiguous timezones by default" do
+    proc{Sequel.database_to_application_timestamp('2004-10-31T01:30:00')}.should raise_error(Sequel::InvalidValue)
+  end
+
+  it "should support tzinfo_disambiguator= to handle ambiguous timezones automatically" do
+    Sequel.tzinfo_disambiguator = proc{|datetime, periods| periods.first}
+    Sequel.database_to_application_timestamp('2004-10-31T01:30:00').should == DateTime.parse('2004-10-30T22:30:00-07:00')
+  end
+
   it "should assume datetimes coming out of the database that don't have an offset as coming from database_timezone" do
     dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30')
     dt.should == @dt

data/spec/extensions/pg_auto_parameterize_spec.rb

@@ -62,4 +62,9 @@ describe "pg_auto_parameterize extension" do
   it "should not auto parameterize when using cursors" do
     @db[:table].filter(:a=>1).use_cursor.opts[:no_auto_parameterize].should be_true
   end
+
+  it "should have a working create_view" do
+    @db.create_view :foo, @db[:table].filter(:a=>1)
+    @db.sqls.should == ["CREATE VIEW foo AS SELECT * FROM table WHERE (a = 1)"]
+  end
 end

data/spec/extensions/pg_json_spec.rb

@@ -39,6 +39,20 @@ describe "pg_json extension" do
   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)
+
+    begin
+      Sequel.instance_eval do
+        alias pj parse_json
+        def parse_json(v)
+          v
+        end
+      end
+      proc{@m.parse_json('1')}.should raise_error(Sequel::InvalidValue)
+    ensure
+      Sequel.instance_eval do
+        alias parse_json pj
+      end
+    end
   end
 
   it "should literalize HStores to strings correctly" do

data/spec/extensions/pg_row_spec.rb

@@ -144,6 +144,17 @@ describe "pg_row extension" do
     db.register_row_type(:foo)
     db.sqls.should == ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
       "SELECT attname, atttypid FROM pg_attribute WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
+
+    begin
+      pgnt = Sequel::Postgres::PG_NAMED_TYPES.dup
+      Sequel::Postgres::PG_NAMED_TYPES.clear
+      db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+      db.reset_conversion_procs
+      db.sqls.should == ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
+        "SELECT attname, atttypid FROM pg_attribute WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
+    ensure
+      Sequel::Postgres::PG_NAMED_TYPES.replace pgnt
+    end
   end
 
   it "should handle ArrayRows and HashRows in bound variables" do

data/spec/extensions/pretty_table_spec.rb

@@ -44,7 +44,7 @@ describe "PrettyTable" do
     @data3 = [
       {:aaa => 1},
       {:bb => 2},
-      {:c => 3}
+      {:c => 3.1}
     ]
 
     @output = StringIO.new
@@ -80,7 +80,7 @@ describe "PrettyTable" do
     Sequel::PrettyTable.print(@data3, [:aaa, :bb, :c])
     @output.rewind
     @output.read.should == \
-      "+---+--+-+\n|aaa|bb|c|\n+---+--+-+\n|  1|  | |\n|   | 2| |\n|   |  |3|\n+---+--+-+\n"
+      "+---+--+---+\n|aaa|bb|c  |\n+---+--+---+\n|  1|  |   |\n|   | 2|   |\n|   |  |3.1|\n+---+--+---+\n"
   end
   
   specify "should print only the specified columns" do

data/spec/extensions/query_spec.rb

@@ -77,15 +77,18 @@ describe "Dataset#query" do
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM xyz ORDER BY stamp"
   end
-  
-  specify "should raise on non-chainable method calls" do
-    proc {@d.query {first_source}}.should raise_error(Sequel::Error)
+
+  specify "should support blocks that end in nil" do
+    condition = false
+    q = @d.query do
+      from :xyz
+      order_by :stamp if condition
+    end
+    q.sql.should == "SELECT * FROM xyz"
   end
   
-  specify "should raise on each, insert, update, delete" do
-    proc {@d.query {each}}.should raise_error(Sequel::Error)
-    proc {@d.query {insert(:x => 1)}}.should raise_error(Sequel::Error)
-    proc {@d.query {update(:x => 1)}}.should raise_error(Sequel::Error)
-    proc {@d.query {delete}}.should raise_error(Sequel::Error)
+  specify "should raise on non-chainable method calls" do
+    proc {@d.query {row_proc}}.should raise_error(Sequel::Error)
+    proc {@d.query {all}}.should raise_error(Sequel::Error)
   end
 end

data/spec/extensions/serialization_spec.rb

@@ -114,6 +114,26 @@ describe "Serialization plugin" do
       "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
   
+  it "should handle old non-base-64 encoded marshal serialization format" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :marshal, :abc, :def
+    @c.dataset._fetch = [:id => 1, :abc =>Marshal.dump(1), :def =>Marshal.dump('hello')]
+
+    o = @c.first
+    o.abc.should == 1
+    o.def.should == "hello"
+  end
+
+  it "should raise exception for bad marshal data" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :marshal, :abc, :def
+    @c.dataset._fetch = [:id => 1, :abc =>'foo', :def =>'bar']
+
+    o = @c.first
+    proc{o.abc}.should raise_error
+    proc{o.def}.should raise_error
+  end
+  
   it "should translate values to and from json serialization format using accessor methods" do
     @c.set_primary_key :id
     @c.plugin :serialization, :json, :abc, :def