sequel 3.21.0 → 3.39.0

data/spec/extensions/dataset_associations_spec.rb

@@ -0,0 +1,199 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DatasetAssociations" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.columns :id, :name
+    @Album.columns :id, :name, :artist_id
+    @Tag.columns :id, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album
+    @Artist.one_to_one :first_album, :class=>@Album
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag
+    @Tag.many_to_many :albums, :class=>@Album
+    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    ds = @Album.artists
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    ds = @Artist.albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    ds = @Artist.first_albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    ds = @Album.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should work for many_through_many associations" do
+    ds = @Artist.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should have an associated method that takes an association symbol" do
+    ds = @Album.associated(:artist)
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should raise an Error if an invalid association is given to associated" do
+    proc{@Album.associated(:foo)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an Error if an unrecognized association type is used" do
+    @Album.association_reflection(:artist)[:type] = :foo
+    proc{@Album.artists}.should raise_error(Sequel::Error)
+  end
+
+  it "should work correctly when chaining" do
+    ds = @Artist.albums.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
+  end
+
+  it "should deal correctly with filters before the association method" do
+    @Artist.filter(:id=>1).albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists WHERE (id = 1)))"
+  end
+
+  it "should deal correctly with filters after the association method" do
+    @Artist.albums.filter(:id=>1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with block on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums do |ds| ds.filter(:id=>1..100) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :conditions option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :conditions=>{:id=>1..100}
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :distinct option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :distinct=>true
+    @Artist.albums.sql.should == "SELECT DISTINCT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should deal correctly with :eager option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager=>:tags
+    @Artist.albums.opts[:eager].should == {:tags=>nil}
+  end
+
+  it "should deal correctly with :eager_block option on the association, ignoring the association block" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager_block=>proc{|ds| ds.filter(:id=>1..100)} do |ds| ds.filter(:id=>2..200) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :extend option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :extend=>Module.new{def foo(x) filter(:id=>x) end}
+    @Artist.albums.foo(1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with :order option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :order=>:name
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists)) ORDER BY name"
+  end
+
+  it "should deal correctly with :select option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :select=>[:id, :name]
+    @Artist.albums.sql.should == "SELECT id, name FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+end
+
+describe "Sequel::Plugins::DatasetAssociations with composite keys" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.set_primary_key([:id1, :id2])
+    @Album.set_primary_key([:id1, :id2])
+    @Tag.set_primary_key([:id1, :id2])
+
+    @Artist.columns :id1, :id2, :name
+    @Album.columns :id1, :id2, :name, :artist_id1, :artist_id2
+    @Tag.columns :id1, :id2, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Artist.one_to_one :first_album, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_many :tags, :class=>@Tag, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
+    @Tag.many_to_many :albums, :class=>@Album, :right_key=>[:album_id1, :album_id2], :left_key=>[:tag_id1, :tag_id2]
+    @Artist.many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    @Album.artists.sql.should == "SELECT * FROM artists WHERE ((artists.id1, artists.id2) IN (SELECT albums.artist_id1, albums.artist_id2 FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    @Artist.first_albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    @Album.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work for many_through_many associations" do
+    @Artist.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work correctly when chaining" do
+    @Artist.albums.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))"
+  end
+end

data/spec/extensions/defaults_setter_spec.rb

@@ -0,0 +1,88 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DefaultsSetter" do
+  before do
+    @db = db = Sequel::Database.new
+    @c = c = Class.new(Sequel::Model(db[:foo]))
+    @c.instance_variable_set(:@db_schema, {:a=>{}})
+    @c.plugin :defaults_setter
+    @c.columns :a
+    @pr = proc{|x| db.meta_def(:schema){|*| [[:a, {:ruby_default => x}]]}; c.dataset = c.dataset; c}
+  end
+  after do
+    Sequel.datetime_class = Time
+  end
+
+  it "should set default value upon initialization" do
+    @pr.call(2).new.values.should == {:a=>2}
+  end
+
+  it "should not mark the column as modified" do
+    @pr.call(2).new.changed_columns.should == []
+  end
+
+  it "should not set a default of nil" do
+    @pr.call(nil).new.values.should == {}
+  end
+
+  it "should set a default of false" do
+    @pr.call(false).new.values.should == {:a=>false}
+  end
+
+  it "should handle Sequel::CURRENT_DATE default by using the current Date" do
+    @pr.call(Sequel::CURRENT_DATE).new.a.should == Date.today
+  end
+
+  it "should handle Sequel::CURRENT_TIMESTAMP default by using the current Time" do
+    t = @pr.call(Sequel::CURRENT_TIMESTAMP).new.a
+    t.should be_a_kind_of(Time)
+    (t - Time.now).should < 1
+  end
+
+  it "should handle Sequel::CURRENT_TIMESTAMP default by using the current DateTime if Sequel.datetime_class is DateTime" do
+    Sequel.datetime_class = DateTime
+    t = @pr.call(Sequel::CURRENT_TIMESTAMP).new.a
+    t.should be_a_kind_of(DateTime)
+    (t - DateTime.now).should < 1/86400.0
+  end
+
+  it "should not override a given value" do
+    @pr.call(2)
+    @c.new('a'=>3).values.should == {:a=>3}
+    @c.new('a'=>nil).values.should == {:a=>nil}
+  end
+
+  it "should work correctly when subclassing" do
+    Class.new(@pr.call(2)).new.values.should == {:a=>2}
+  end
+
+  it "should contain the default values in default_values" do
+    @pr.call(2).default_values.should == {:a=>2}
+    @pr.call(nil).default_values.should == {}
+  end
+
+  it "should allow modifications of default values" do
+    @pr.call(2)
+    @c.default_values[:a] = 3
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should allow proc default values" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{3}
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should have procs that set default values set them to nil" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{nil}
+    @c.new.values.should == {:a => nil}
+  end
+
+  it "should work correctly on a model without a dataset" do
+    @pr.call(2)
+    c = Class.new(Sequel::Model(@db[:bar]))
+    c.plugin :defaults_setter
+    c.default_values.should == {:a=>2}
+  end
+end

data/spec/extensions/dirty_spec.rb

@@ -0,0 +1,155 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::Dirty" do
+  before do
+    @db = Sequel.mock(:fetch=>{:initial=>'i', :initial_changed=>'ic'}, :numrows=>1)
+    @c = Class.new(Sequel::Model(@db[:c]))
+    @c.plugin :dirty
+    @c.columns :initial, :initial_changed, :missing, :missing_changed
+  end
+
+  shared_examples_for "dirty plugin" do
+    it "initial_value should be the current value if value has not changed" do
+      @o.initial_value(:initial).should == 'i'
+      @o.initial_value(:missing).should == nil
+    end
+
+    it "initial_value should be the intial value if value has changed" do
+      @o.initial_value(:initial_changed).should == 'ic'
+      @o.initial_value(:missing_changed).should == nil
+    end
+
+    it "initial_value should handle case where initial value is reassigned later" do
+      @o.initial_changed = 'ic'
+      @o.initial_value(:initial_changed).should == 'ic'
+      @o.missing_changed = nil
+      @o.initial_value(:missing_changed).should == nil
+    end
+
+    it "changed_columns should handle case where initial value is reassigned later" do
+      @o.changed_columns.should == [:initial_changed, :missing_changed]
+      @o.initial_changed = 'ic'
+      @o.changed_columns.should == [:missing_changed]
+      @o.missing_changed = nil
+      @o.changed_columns.should == [:missing_changed]
+    end
+
+    it "column_change should give initial and current values if there has been a change made" do
+      @o.column_change(:initial_changed).should == ['ic', 'ic2']
+      @o.column_change(:missing_changed).should == [nil, 'mc2']
+    end
+
+    it "column_change should be nil if no change has been made" do
+      @o.column_change(:initial).should == nil
+      @o.column_change(:missing).should == nil
+    end
+
+    it "column_changed? should return whether the column has changed" do
+      @o.column_changed?(:initial).should == false
+      @o.column_changed?(:initial_changed).should == true
+      @o.column_changed?(:missing).should == false
+      @o.column_changed?(:missing_changed).should == true
+    end
+
+    it "column_changed? should handle case where initial value is reassigned later" do
+      @o.initial_changed = 'ic'
+      @o.column_changed?(:initial_changed).should == false
+      @o.missing_changed = nil
+      @o.column_changed?(:missing_changed).should == false
+    end
+
+    it "changed_columns should handle case where initial value is reassigned later" do
+      @o.changed_columns.should == [:initial_changed, :missing_changed]
+      @o.initial_changed = 'ic'
+      @o.changed_columns.should == [:missing_changed]
+      @o.missing_changed = nil
+      @o.changed_columns.should == [:missing_changed]
+    end
+
+    it "column_changes should give initial and current values" do
+      @o.column_changes.should == {:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2']}
+    end
+
+    it "reset_column should reset the column to its initial value" do
+      @o.reset_column(:initial)
+      @o.initial.should == 'i'
+      @o.reset_column(:initial_changed)
+      @o.initial_changed.should == 'ic'
+      @o.reset_column(:missing)
+      @o.missing.should == nil
+      @o.reset_column(:missing_changed)
+      @o.missing_changed.should == nil
+    end
+
+    it "reset_column should remove missing values from the values" do
+      @o.reset_column(:missing)
+      @o.values.has_key?(:missing).should == false
+      @o.reset_column(:missing_changed)
+      @o.values.has_key?(:missing_changed).should == false
+    end
+    
+    it "refresh should clear the cached initial values" do
+      @o.refresh
+      @o.column_changes.should == {}
+    end
+    
+    it "will_change_column should be used to signal in-place modification to column" do
+      @o.will_change_column(:initial)
+      @o.initial << 'b'
+      @o.column_change(:initial).should == ['i', 'ib']
+      @o.will_change_column(:initial_changed)
+      @o.initial_changed << 'b'
+      @o.column_change(:initial_changed).should == ['ic', 'ic2b']
+      @o.will_change_column(:missing)
+      @o.values[:missing] = 'b'
+      @o.column_change(:missing).should == [nil, 'b']
+      @o.will_change_column(:missing_changed)
+      @o.missing_changed << 'b'
+      @o.column_change(:missing_changed).should == [nil, 'mc2b']
+    end
+
+    it "will_change_column should different types of existing objects" do
+      [nil, true, false, Class.new{undef_method :clone}.new, Class.new{def clone; raise TypeError; end}.new].each do |v|
+        o = @c.new(:initial=>v)
+        o.will_change_column(:initial)
+        o.initial = 'a'
+        o.column_change(:initial).should == [v, 'a']
+      end
+    end
+
+    it "save should clear the cached initial values" do
+      @o.save
+      @o.column_changes.should == {}
+    end
+
+    it "save_changes should clear the cached initial values" do
+      @o.save_changes
+      @o.column_changes.should == {}
+    end
+  end
+
+  describe "with new instance" do
+    before do
+      @o = @c.new(:initial=>'i', :initial_changed=>'ic')
+      @o.initial_changed = 'ic2'
+      @o.missing_changed = 'mc2'
+    end
+
+    it_should_behave_like "dirty plugin"
+  end
+
+  describe "with existing instance" do
+    before do
+      @o = @c[1]
+      @o.initial_changed = 'ic2'
+      @o.missing_changed = 'mc2'
+    end
+
+    it_should_behave_like "dirty plugin"
+
+    it "previous_changes should be the previous changes after saving" do
+      @o.save
+      @o.previous_changes.should == {:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2']}
+    end
+  end
+end

data/spec/extensions/eager_each_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::EagerEach" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.columns :id, :parent_id
+    @c.plugin :eager_each
+    @c.one_to_many :children, :class=>@c, :key=>:parent_id
+    @c.db.sqls
+  end
+
+  it "should make #each on an eager dataset do eager loading" do
+    a = []
+    ds = @c.eager(:children)
+    ds._fetch = [{:id=>1, :parent_id=>nil}, {:id=>2, :parent_id=>nil}]
+    @c.dataset._fetch = [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>2}, {:id=>6, :parent_id=>2}]
+    ds.each{|c| a << c}
+    a.should == [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
+    @c.db.sqls.should == ['SELECT * FROM items', 'SELECT * FROM items WHERE (items.parent_id IN (1, 2))']
+  end
+
+  it "should make #each on an eager_graph dataset do eager loading" do
+    a = []
+    ds = @c.eager_graph(:children)
+    ds._fetch = []
+    ds._fetch = [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}, {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}, {:id=>2, :parent_id=>nil, :children_id=>6, :children_parent_id=>2}]
+    ds.each{|c| a << c}
+    a.should == [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
+    @c.db.sqls.should == ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
+  end
+
+end

data/spec/extensions/eval_inspect_spec.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "eval_inspect extension" do
+  before do
+    @ds = Sequel.mock.dataset
+    @ds.meta_def(:supports_window_functions?){true}
+    @ds.meta_def(:literal_blob_append){|sql, s| sql << "X'#{s}'"}
+  end
+
+  specify "should make eval(obj.inspect) == obj for all Sequel::SQL::Expression subclasses" do
+    [
+      # Objects with components where eval(inspect) == self
+      Sequel::SQL::AliasedExpression.new(:b, :a),
+      Sequel::SQL::CaseExpression.new({:b=>:a}, :c),
+      Sequel::SQL::CaseExpression.new({:b=>:a}, :c, :d),
+      Sequel::SQL::Cast.new(:a, :b),
+      Sequel::SQL::ColumnAll.new(:a),
+      Sequel::SQL::ComplexExpression.new(:'=', :b, :a),
+      Sequel::SQL::Constant.new(:a),
+      Sequel::CURRENT_DATE,
+      Sequel::CURRENT_TIMESTAMP,
+      Sequel::CURRENT_TIME,
+      Sequel::SQLTRUE,
+      Sequel::SQLFALSE,
+      Sequel::NULL,
+      Sequel::NOTNULL,
+      Sequel::SQL::Function.new(:a, :b, :c),
+      Sequel::SQL::Identifier.new(:a),
+      Sequel::SQL::JoinClause.new(:inner, :b, :c),
+      Sequel::SQL::JoinOnClause.new({:d=>:a}, :inner, :b, :c),
+      Sequel::SQL::JoinUsingClause.new([:a], :inner, :b, :c),
+      Sequel::SQL::PlaceholderLiteralString.new('? = ?', [:a, :b]),
+      Sequel::SQL::PlaceholderLiteralString.new(':a = :b', [{:a=>:b, :b=>42}]),
+      Sequel::SQL::OrderedExpression.new(:a),
+      Sequel::SQL::OrderedExpression.new(:a, false),
+      Sequel::SQL::OrderedExpression.new(:a, false, :nulls=>:first),
+      Sequel::SQL::OrderedExpression.new(:a, false, :nulls=>:last),
+      Sequel::SQL::QualifiedIdentifier.new(:b, :a),
+      Sequel::SQL::Subscript.new(:a, [1, 2]),
+      Sequel::SQL::Window.new(:order=>:a, :partition=>:b),
+      Sequel::SQL::WindowFunction.new(Sequel::SQL::Function.new(:a, :b, :c), Sequel::SQL::Window.new(:order=>:a, :partition=>:b)),
+      Sequel::SQL::Wrapper.new(:a),
+      
+      # Objects with components where eval(inspect) != self
+      Sequel::SQL::AliasedExpression.new(Sequel::SQL::Blob.new('s'), :a),
+      Sequel::SQL::AliasedExpression.new(Sequel::LiteralString.new('s'), :a),
+      Sequel::SQL::PlaceholderLiteralString.new('(a, b) IN ?', [Sequel::SQL::ValueList.new([[1, 2]])]),
+      Sequel::SQL::CaseExpression.new({{:d=>Sequel::LiteralString.new('e')}=>:a}, :c, :d),
+      Sequel::SQL::AliasedExpression.new(Date.new(2011, 10, 11), :a),
+      Sequel::SQL::AliasedExpression.new(Sequel::SQLTime.create(10, 20, 30, 500000.125), :a),
+      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30), :a),
+      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30, 0.25), :a),
+      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30, -0.25), :a),
+      Sequel::SQL::AliasedExpression.new(Time.local(2011, 9, 11, 10, 20, 30), :a),
+      Sequel::SQL::AliasedExpression.new(Time.local(2011, 9, 11, 10, 20, 30, 500000.125), :a),
+      Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30), :a),
+      Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30, 500000.125), :a),
+      Sequel::SQL::AliasedExpression.new(BigDecimal.new('1.000000000000000000000000000000000000000000000001'), :a),
+      Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_DATE, :a),
+      Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_TIMESTAMP, :a),
+    ].each do |o|
+      v = eval(o.inspect)
+      v.should == o
+      @ds.literal(v).should == @ds.literal(o)
+    end
+  end
+end

data/spec/extensions/force_encoding_spec.rb

@@ -74,12 +74,13 @@ describe "force_encoding plugin" do
   
   specify "should work when saving new model instances" do
     o = @c.new
-    @c.dataset = ds = MODEL_DB[:a]
+    ds = MODEL_DB[:a]
     def ds.first
       s = 'blah'
       s.force_encoding('US-ASCII')
       {:id=>1, :x=>s}
     end
+    @c.dataset = ds
     o.save
     o.x.should == 'blah'
     o.x.encoding.should == @e1
@@ -87,12 +88,13 @@ describe "force_encoding plugin" do
   
   specify "should work when refreshing model instances" do
     o = @c.load(:id=>1, :x=>'as')
-    @c.dataset = ds = MODEL_DB[:a]
+    ds = MODEL_DB[:a]
     def ds.first
       s = 'blah'
       s.force_encoding('US-ASCII')
       {:id=>1, :x=>s}
     end
+    @c.dataset = ds
     o.refresh
     o.x.should == 'blah'
     o.x.encoding.should == @e1