sequel 3.37.0 → 3.38.0

data/spec/model/eager_loading_spec.rb

@@ -179,7 +179,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should handle qualified order clauses when eagerly loading a single one_to_one association using the :correlated_subquery strategy" do
-    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>[:tracks__name, :tracks__name.desc, :name.qualify(:tracks), :name.qualify(:t), 1]
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>[:tracks__name, Sequel.desc(:tracks__name), Sequel.qualify(:tracks, :name), Sequel.qualify(:t, :name), 1]
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) ORDER BY t1.name, t1.name DESC, t1.name, t.name, 1 LIMIT 1))) ORDER BY tracks.name, tracks.name DESC, tracks.name, t.name, 1']
@@ -1303,21 +1303,21 @@ describe Sequel::Model, "#eager_graph" do
   end
 
   it "should respect the association's :graph_block option" do 
-    GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_block=>proc{|ja,lja,js| {:active.qualify(ja)=>true}}
+    GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_block=>proc{|ja,lja,js| {Sequel.qualify(ja, :active)=>true}}
     GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON ((active_band.id = albums.band_id) AND (active_band.active IS TRUE))"
 
-    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_block=>proc{|ja,lja,js| {:id.qualify(ja)=>(0..100)}}
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_block=>proc{|ja,lja,js| {Sequel.qualify(ja, :id)=>(0..100)}}
     GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON ((right_tracks.album_id = albums.id) AND (right_tracks.id >= 0) AND (right_tracks.id <= 100))'
 
-    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_block=>proc{|ja,lja,js| {true=>:active.qualify(lja)}}
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_block=>proc{|ja,lja,js| {true=>Sequel.qualify(lja, :active)}}
     GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
   end
 
-  it "should respect the association's :graph_join_block option" do 
-    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_block=>proc{|ja,lja,js| {:active.qualify(ja)=>true}}
+  it "should respect the association's :graph_join_table_block option" do 
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_block=>proc{|ja,lja,js| {Sequel.qualify(ja, :active)=>true}}
     GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON ((ag.album_id = albums.id) AND (ag.active IS TRUE)) LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
 
-    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_block=>proc{|ja,lja,js| {true=>:active.qualify(lja)}}, :graph_join_table_block=>proc{|ja,lja,js| {true=>:active.qualify(lja)}}
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_block=>proc{|ja,lja,js| {true=>Sequel.qualify(lja, :active)}}, :graph_join_table_block=>proc{|ja,lja,js| {true=>Sequel.qualify(lja, :active)}}
     GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON ((ag.album_id = albums.id) AND ('t' = albums.active)) LEFT OUTER JOIN genres AS active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
   end
 
@@ -1351,7 +1351,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_only_conditions=>{:active=>true}
     GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.active IS TRUE) LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
 
-    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_only_conditions=>(:price + 2 > 100), :graph_join_table_only_conditions=>"active"
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_only_conditions=>(Sequel.expr(:price) + 2 > 100), :graph_join_table_only_conditions=>"active"
     GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON (active) LEFT OUTER JOIN genres AS active_genres ON ((price + 2) > 100)"
   end
 
@@ -1365,7 +1365,7 @@ describe Sequel::Model, "#eager_graph" do
   end
 
   it "should only qualify unqualified symbols, identifiers, or ordered versions in association's :order" do
-    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[:blah__id.identifier, :blah__id.identifier.desc, :blah__id.desc, :blah__id, :album_id, :album_id.desc, 1, 'RANDOM()'.lit, :a.qualify(:b)]
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[Sequel.identifier(:blah__id), Sequel.identifier(:blah__id).desc, Sequel.desc(:blah__id), :blah__id, :album_id, Sequel.desc(:album_id), 1, Sequel.lit('RANDOM()'), Sequel.qualify(:b, :a)]
     GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id) ORDER BY right_tracks.blah__id, right_tracks.blah__id DESC, blah.id DESC, blah.id, right_tracks.album_id, right_tracks.album_id DESC, 1, RANDOM(), b.a'
   end
 
@@ -1415,16 +1415,16 @@ describe Sequel::Model, "#eager_graph" do
   
   it "should handle eager loading with schemas and aliases of different types" do
     GraphAlbum.eager_graph(:band).join(:s__genres, [:b_id]).eager_graph(:genres).sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
-    GraphAlbum.eager_graph(:band).join(:genres.qualify(:s), [:b_id]).eager_graph(:genres).sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
-    GraphAlbum.eager_graph(:band).join(:s__b.as('genres'), [:b_id]).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
-    GraphAlbum.eager_graph(:band).join(:s__b, [:b_id], :genres.identifier).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
-    GraphAlbum.eager_graph(:band).join(:genres.identifier, [:b_id]).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(Sequel.qualify(:s, :genres), [:b_id]).eager_graph(:genres).sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(Sequel.expr(:s__b).as('genres'), [:b_id]).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(:s__b, [:b_id], Sequel.identifier(:genres)).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(Sequel.identifier(:genres), [:b_id]).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
     GraphAlbum.eager_graph(:band).join('genres', [:b_id]).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
   end
   
   it "should raise errors if invalid aliases or table styles are used" do
-    proc{GraphAlbum.from_self(:alias=>:bands.qualify(:s)).eager_graph(:band)}.should raise_error(Sequel::Error)
-    proc{GraphAlbum.from('?'.lit(:bands)).eager_graph(:band)}.should raise_error(Sequel::Error)
+    proc{GraphAlbum.from_self(:alias=>Sequel.qualify(:s, :bands)).eager_graph(:band)}.should raise_error(Sequel::Error)
+    proc{GraphAlbum.from(Sequel.lit('?', :bands)).eager_graph(:band)}.should raise_error(Sequel::Error)
   end
 
   it "should eagerly load schema qualified tables correctly with joins" do

data/spec/model/model_spec.rb

@@ -20,35 +20,35 @@ describe "Sequel::Model()" do
   end
 
   it "should return a model subclass with a dataset with the default database and given table name if given a LiteralString" do
-    c = Sequel::Model('blah'.lit)
+    c = Sequel::Model(Sequel.lit('blah'))
     c.superclass.should == Sequel::Model
     c.db.should == @db
-    c.table_name.should == 'blah'.lit
+    c.table_name.should == Sequel.lit('blah')
   end
 
   it "should return a model subclass with a dataset with the default database and given table name if given an SQL::Identifier" do
-    c = Sequel::Model(:blah.identifier)
+    c = Sequel::Model(Sequel.identifier(:blah))
     c.superclass.should == Sequel::Model
     c.db.should == @db
-    c.table_name.should == :blah.identifier
+    c.table_name.should == Sequel.identifier(:blah)
   end
 
   it "should return a model subclass with a dataset with the default database and given table name if given an SQL::QualifiedIdentifier" do
-    c = Sequel::Model(:blah.qualify(:boo))
+    c = Sequel::Model(Sequel.qualify(:boo, :blah))
     c.superclass.should == Sequel::Model
     c.db.should == @db
-    c.table_name.should == :blah.qualify(:boo)
+    c.table_name.should == Sequel.qualify(:boo, :blah)
   end
 
   it "should return a model subclass with a dataset with the default database and given table name if given an SQL::AliasedExpression" do
-    c = Sequel::Model(:blah.as(:boo))
+    c = Sequel::Model(Sequel.as(:blah, :boo))
     c.superclass.should == Sequel::Model
     c.db.should == @db
     c.table_name.should == :boo
   end
 
   it "should return a model subclass with the given dataset if given a dataset using an SQL::Identifier" do
-    ds = @db[:blah.identifier]
+    ds = @db[Sequel.identifier(:blah)]
     c = Sequel::Model(ds)
     c.superclass.should == Sequel::Model
     c.dataset.should == ds
@@ -84,29 +84,29 @@ describe "Sequel::Model()" do
 
     it "should work without raising an exception with an SQL::Identifier " do
       proc do
-        class ::Album < Sequel::Model(:table.identifier); end
-        class ::Album < Sequel::Model(:table.identifier); end
+        class ::Album < Sequel::Model(Sequel.identifier(:table)); end
+        class ::Album < Sequel::Model(Sequel.identifier(:table)); end
       end.should_not raise_error
     end
 
     it "should work without raising an exception with an SQL::QualifiedIdentifier " do
       proc do
-        class ::Album < Sequel::Model(:table.qualify(:schema)); end
-        class ::Album < Sequel::Model(:table.qualify(:schema)); end
+        class ::Album < Sequel::Model(Sequel.qualify(:schema, :table)); end
+        class ::Album < Sequel::Model(Sequel.qualify(:schema, :table)); end
       end.should_not raise_error
     end
 
     it "should work without raising an exception with an SQL::AliasedExpression" do
       proc do
-        class ::Album < Sequel::Model(:table.as(:alias)); end
-        class ::Album < Sequel::Model(:table.as(:alias)); end
+        class ::Album < Sequel::Model(Sequel.as(:table, :alias)); end
+        class ::Album < Sequel::Model(Sequel.as(:table, :alias)); end
       end.should_not raise_error
     end
 
     it "should work without raising an exception with an LiteralString" do
       proc do
-        class ::Album < Sequel::Model('table'.lit); end
-        class ::Album < Sequel::Model('table'.lit); end
+        class ::Album < Sequel::Model(Sequel.lit('table')); end
+        class ::Album < Sequel::Model(Sequel.lit('table')); end
       end.should_not raise_error
     end
 
@@ -126,16 +126,16 @@ describe "Sequel::Model()" do
 
     it "should work without raising an exception with a dataset with an SQL::Identifier" do
       proc do
-        class ::Album < Sequel::Model(@db[:table.identifier]); end
-        class ::Album < Sequel::Model(@db[:table.identifier]); end
+        class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
+        class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
       end.should_not raise_error
     end
 
     it "should raise an exception if anonymous model caching is disabled" do
       Sequel::Model.cache_anonymous_models = false
       proc do
-        class ::Album < Sequel::Model(@db[:table.identifier]); end
-        class ::Album < Sequel::Model(@db[:table.identifier]); end
+        class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
+        class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
       end.should raise_error
     end
   end
@@ -195,25 +195,25 @@ describe Sequel::Model, "dataset & schema" do
 
   it "set_dataset should take a LiteralString" do
     @model.db = MODEL_DB
-    @model.set_dataset('foo'.lit)
-    @model.table_name.should == 'foo'.lit
+    @model.set_dataset(Sequel.lit('foo'))
+    @model.table_name.should == Sequel.lit('foo')
   end
 
   it "set_dataset should take an SQL::Identifier" do
     @model.db = MODEL_DB
-    @model.set_dataset(:foo.identifier)
-    @model.table_name.should == :foo.identifier
+    @model.set_dataset(Sequel.identifier(:foo))
+    @model.table_name.should == Sequel.identifier(:foo)
   end
 
   it "set_dataset should take an SQL::QualifiedIdentifier" do
     @model.db = MODEL_DB
-    @model.set_dataset(:foo.qualify(:bar))
-    @model.table_name.should == :foo.qualify(:bar)
+    @model.set_dataset(Sequel.qualify(:bar, :foo))
+    @model.table_name.should == Sequel.qualify(:bar, :foo)
   end
 
   it "set_dataset should take an SQL::AliasedExpression" do
     @model.db = MODEL_DB
-    @model.set_dataset(:foo.as(:bar))
+    @model.set_dataset(Sequel.as(:foo, :bar))
     @model.table_name.should == :bar
   end
 
@@ -361,12 +361,12 @@ describe Sequel::Model, ".subset" do
   specify "should create a filter on the underlying dataset" do
     proc {@c.new_only}.should raise_error(NoMethodError)
     
-    @c.subset(:new_only) {:age.sql_number < 'new'}
+    @c.subset(:new_only){age < 'new'}
     
     @c.new_only.sql.should == "SELECT * FROM items WHERE (age < 'new')"
     @c.dataset.new_only.sql.should == "SELECT * FROM items WHERE (age < 'new')"
     
-    @c.subset(:pricey) {:price.sql_number > 100}
+    @c.subset(:pricey){price > 100}
     
     @c.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
     @c.dataset.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
@@ -393,15 +393,15 @@ describe Sequel::Model, ".find" do
     @c.find(:name => 'sharon').should be_a_kind_of(@c)
     MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"]
 
-    @c.find(:name.like('abc%')).should be_a_kind_of(@c)
+    @c.find(Sequel.expr(:name).like('abc%')).should be_a_kind_of(@c)
     MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (name LIKE 'abc%') LIMIT 1"]
   end
   
   specify "should accept filter blocks" do
-    @c.find{:id.sql_number > 1}.should be_a_kind_of(@c)
+    @c.find{id > 1}.should be_a_kind_of(@c)
     MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id > 1) LIMIT 1"]
 
-    @c.find {(:x.sql_number > 1) & (:y.sql_number < 2)}.should be_a_kind_of(@c)
+    @c.find{(x > 1) & (y < 2)}.should be_a_kind_of(@c)
     MODEL_DB.sqls.should == ["SELECT * FROM items WHERE ((x > 1) AND (y < 2)) LIMIT 1"]
   end
 end

data/spec/model/record_spec.rb

@@ -1,5 +1,21 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+describe "Model#values" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+  end
+
+  it "should return the hash of model values" do
+    hash = {:x=>1}
+    @c.load(hash).values.should equal(hash)
+  end
+
+  it "should be aliased as to_hash" do
+    hash = {:x=>1}
+    @c.load(hash).to_hash.should equal(hash)
+  end
+end
+
 describe "Model#save server use" do
   before do
     @db = Sequel.mock(:autoid=>proc{|sql| 10}, :fetch=>{:x=>1, :id=>10}, :servers=>{:blah=>{}, :read_only=>{}})

data/spec/model/spec_helper.rb

@@ -1,11 +1,7 @@
 require 'rubygems'
-unless Object.const_defined?('Sequel')
+unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model') 
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel/core'
-end
-unless Sequel.const_defined?('Model')
-  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel/model'
+  require 'sequel/no_core_ext'
 end
 
 if ENV['SEQUEL_COLUMNS_INTROSPECTION']

data/spec/model/validations_spec.rb

@@ -65,7 +65,7 @@ describe Sequel::Model::Errors do
     @errors.full_messages.should == []
     
     @errors[:blow] << 'blieuh'
-    @errors[:blow] << 'blich'.lit
+    @errors[:blow] << Sequel.lit('blich')
     @errors[:blay] << 'bliu'
     msgs = @errors.full_messages
     msgs.size.should == 3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 3.37.0
+  version: 3.38.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-02 00:00:00.000000000 Z
+date: 2012-08-01 00:00:00.000000000 Z
 dependencies: []
 description: The Database Toolkit for Ruby
 email: code@jeremyevans.net
@@ -42,6 +42,7 @@ extra_rdoc_files:
 - doc/transactions.rdoc
 - doc/thread_safety.rdoc
 - doc/object_model.rdoc
+- doc/core_extensions.rdoc
 - doc/release_notes/1.0.txt
 - doc/release_notes/1.1.txt
 - doc/release_notes/1.3.txt
@@ -98,6 +99,7 @@ extra_rdoc_files:
 - doc/release_notes/3.35.0.txt
 - doc/release_notes/3.36.0.txt
 - doc/release_notes/3.37.0.txt
+- doc/release_notes/3.38.0.txt
 files:
 - MIT-LICENSE
 - CHANGELOG
@@ -172,6 +174,7 @@ files:
 - doc/release_notes/3.35.0.txt
 - doc/release_notes/3.36.0.txt
 - doc/release_notes/3.37.0.txt
+- doc/release_notes/3.38.0.txt
 - doc/sharding.rdoc
 - doc/sql.rdoc
 - doc/validations.rdoc
@@ -182,6 +185,7 @@ files:
 - doc/transactions.rdoc
 - doc/thread_safety.rdoc
 - doc/object_model.rdoc
+- doc/core_extensions.rdoc
 - spec/adapters/firebird_spec.rb
 - spec/adapters/informix_spec.rb
 - spec/adapters/mssql_spec.rb
@@ -276,7 +280,6 @@ files:
 - spec/extensions/query_literals_spec.rb
 - spec/extensions/dirty_spec.rb
 - spec/extensions/pg_json_spec.rb
-- spec/extensions/core_extensions_spec.rb
 - spec/extensions/pg_inet_spec.rb
 - spec/extensions/eval_inspect_spec.rb
 - spec/extensions/pg_range_spec.rb
@@ -284,6 +287,10 @@ files:
 - spec/extensions/pg_range_ops_spec.rb
 - spec/extensions/pg_interval_spec.rb
 - spec/extensions/columns_introspection_spec.rb
+- spec/extensions/pg_row_ops_spec.rb
+- spec/extensions/pg_row_plugin_spec.rb
+- spec/extensions/pg_row_spec.rb
+- spec/extensions/pg_typecast_on_load_spec.rb
 - spec/integration/associations_test.rb
 - spec/integration/database_test.rb
 - spec/integration/dataset_test.rb
@@ -356,6 +363,7 @@ files:
 - spec/files/transaction_specified_migrations/002_create_basic.rb
 - spec/files/transaction_unspecified_migrations/001_create_alt_basic.rb
 - spec/files/transaction_unspecified_migrations/002_create_basic.rb
+- spec/core_extensions_spec.rb
 - lib/sequel.rb
 - lib/sequel/adapters/ado.rb
 - lib/sequel/adapters/ado/mssql.rb
@@ -475,6 +483,8 @@ files:
 - lib/sequel/extensions/split_array_nil.rb
 - lib/sequel/extensions/pg_range_ops.rb
 - lib/sequel/extensions/pg_interval.rb
+- lib/sequel/extensions/pg_row.rb
+- lib/sequel/extensions/pg_row_ops.rb
 - lib/sequel/metaprogramming.rb
 - lib/sequel/model.rb
 - lib/sequel/model/associations.rb
@@ -532,6 +542,8 @@ files:
 - lib/sequel/plugins/many_to_one_pk_lookup.rb
 - lib/sequel/plugins/dirty.rb
 - lib/sequel/plugins/eager_each.rb
+- lib/sequel/plugins/pg_row.rb
+- lib/sequel/plugins/pg_typecast_on_load.rb
 - lib/sequel/timezones.rb
 - lib/sequel/version.rb
 - lib/sequel/ast_transformer.rb
@@ -565,7 +577,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: sequel
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: The Database Toolkit for Ruby