sequel 3.21.0 → 3.41.0

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -0,0 +1,111 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::AssociationPks" do
+  before do
+    @db = Sequel.mock
+    @db.extend_datasets do
+      def select_sql
+        sql = super
+        sql << ' -- prepared' if is_a?(Sequel::Dataset::PreparedStatementMethods)
+        sql
+      end
+    end
+    @Artist = Class.new(Sequel::Model(@db[:artists]))
+    @Artist.columns :id, :id2
+    @Album= Class.new(Sequel::Model(@db[:albums]))
+    @Album.columns :id, :artist_id, :id2, :artist_id2
+    @Tag = Class.new(Sequel::Model(@db[:tags]))
+    @Tag.columns :id, :id2
+    @Artist.plugin :prepared_statements_associations
+    @Album.plugin :prepared_statements_associations
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
+    @Artist.plugin :many_through_many
+    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+    @db.sqls
+  end
+
+  specify "should run correct SQL for associations" do
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1) -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2).artist
+    @db.sqls.should == ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2).tags
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)) -- prepared"]
+
+    @Artist.load(:id=>1).tags
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.artist_id = 1)) -- prepared"]
+  end
+
+  specify "should run correct SQL for composite key associations" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
+    @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>[:album_id, :album_id2], :right_key=>[:tag_id, :tag_id2], :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
+    @Artist.many_through_many :tags, [[:albums, [:artist_id, :artist_id2], [:id, :id2]], [:albums_tags, [:album_id, :album_id2], [:tag_id, :tag_id2]]], :class=>@Tag, :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
+
+    @Artist.load(:id=>1, :id2=>2).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2, :artist_id2=>3).artist
+    @db.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 2) AND (artists.id2 = 3)) LIMIT 1 -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2, :id2=>3).tags
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2) AND (albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) -- prepared"]
+
+    @Artist.load(:id=>1, :id2=>2).tags
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.id2 = albums_tags.album_id2) AND (albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
+  end
+
+  specify "should not run query if no objects can be associated" do
+    @Artist.new.albums.should == []
+    @Album.new.artist.should == nil
+    @db.sqls.should == []
+  end
+
+  specify "should run a regular query if there is a callback" do
+    @Artist.load(:id=>1).albums(proc{|ds| ds})
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :prepared_statement=>false option is used for the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :prepared_statement=>false
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if unrecognized association is used" do
+    a = @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    a[:type] = :foo
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if a block is used when defining the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id do |ds| ds end
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :conditions option is used when defining the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+  end
+
+  specify "should run a regular query if :dataset option is used when defining the association" do
+    album = @Album
+    @Artist.one_to_many :albums, :class=>@Album, :dataset=>proc{album.filter(:artist_id=>id)} 
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :cloning an association that doesn't used prepared statements" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+    @Artist.one_to_many :oalbums, :clone=>:albums
+    @Artist.load(:id=>1).oalbums
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+  end
+end

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "prepared_statements_safe plugin" do
+  before do
+    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
+    @c = Class.new(Sequel::Model(@db[:people]))
+    @c.columns :id, :name, :i
+    @c.instance_variable_set(:@db_schema, {:i=>{}, :name=>{}, :id=>{:primary_key=>true}})
+    @c.plugin :prepared_statements_safe
+    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
+    @db.sqls
+  end
+
+  specify "should load the prepared_statements plugin" do
+    @c.plugins.should include(Sequel::Plugins::PreparedStatements)
+  end
+
+  specify "should set default values correctly" do
+    @c.prepared_statements_column_defaults.should == {:name=>nil, :i=>nil}
+    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    Class.new(@c).prepared_statements_column_defaults.should == {:name=>'foo'}
+  end
+
+  specify "should set default values when creating" do
+    @c.create
+    @db.sqls.first.should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \(NULL, NULL\)/
+    @c.create(:name=>'foo')
+    @db.sqls.first.should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((NULL|'foo'), (NULL|'foo')\)/
+    @c.create(:name=>'foo', :i=>2)
+    @db.sqls.first.should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
+  end 
+
+  specify "should use database default values" do
+    @c.instance_variable_set(:@db_schema, {:i=>{:ruby_default=>2}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    c = Class.new(@c)
+    c.create
+    @db.sqls.first.should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
+  end
+
+  specify "should not set defaults for unparseable dataset default values" do
+    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    c = Class.new(@c)
+    c.create
+    @db.sqls.first.should == "INSERT INTO people (name) VALUES ('foo')"
+  end
+
+  specify "should save all fields when updating" do
+    @p.update(:i=>3)
+    @db.sqls.first.should =~ /UPDATE people SET (name = 'foo'|i = 3), (name = 'foo'|i = 3) WHERE \(id = 1\)/
+  end
+
+  specify "should work with abstract classes" do
+    c = Class.new(Sequel::Model)
+    c.plugin :prepared_statements_safe
+    c1 = Class.new(c)
+    c1.meta_def(:get_db_schema){@db_schema = {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}}}
+    c1.set_dataset(:people)
+    c1.prepared_statements_column_defaults.should == {:name=>'foo'}
+    Class.new(c1).prepared_statements_column_defaults.should == {:name=>'foo'}
+  end
+end

data/spec/extensions/prepared_statements_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "prepared_statements plugin" do
+  before do
+    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
+    @c = Class.new(Sequel::Model(@db[:people]))
+    @c.columns :id, :name, :i
+    @c.plugin :prepared_statements
+    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
+    @ds = @c.dataset
+    @db.sqls
+  end
+
+  specify "should correctly lookup by primary key" do
+    @c[1].should == @p
+    @db.sqls.should == ["SELECT * FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
+  end 
+
+  specify "should correctly delete instance" do
+    @p.destroy.should == @p
+    @db.sqls.should == ["DELETE FROM people WHERE (id = 1)"]
+  end
+
+  specify "should correctly update instance" do
+    @p.update(:name=>'bar').should == @c.load(:id=>1, :name=>'bar', :i => 2)
+    @db.sqls.should == ["UPDATE people SET name = 'bar' WHERE (id = 1)"]
+  end
+
+  specify "should correctly create instance" do
+    @c.create(:name=>'foo').should == @c.load(:id=>1, :name=>'foo', :i => 2)
+    @db.sqls.should == ["INSERT INTO people (name) VALUES ('foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
+  end
+
+  specify "should correctly create instance if dataset supports insert_select" do
+    ds = @c.instance_dataset 
+    def ds.supports_insert_select?
+      true
+    end
+    def @ds.supports_insert_select?
+      true
+    end
+    def @ds.insert_select(h)
+      {:id=>1, :name=>'foo', :i => 2}
+    end
+    def @ds.insert_sql(*)
+      "#{super}#{' RETURNING *' if opts.has_key?(:returning)}"
+    end
+    @c.create(:name=>'foo').should == @c.load(:id=>1, :name=>'foo', :i => 2)
+    @db.sqls.should == ["INSERT INTO people (name) VALUES ('foo') RETURNING *"]
+  end
+
+  specify "should work correctly when subclassing" do
+    c = Class.new(@c)
+    c[1].should == c.load(:id=>1, :name=>'foo', :i=>2)
+    @db.sqls.should == ["SELECT * FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
+  end 
+
+  describe " with placeholder type specifiers" do 
+    before do
+      @ds.meta_def(:requires_placeholder_type_specifiers?){true}
+    end
+
+    specify "should correctly handle without schema type" do
+      @c[1].should == @p
+      @db.sqls.should == ["SELECT * FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
+    end
+
+    specify "should correctly handle with schema type" do
+      @c.db_schema[:id][:type] = :integer
+      ds = @c.send(:prepared_lookup)
+      def ds.literal_symbol_append(sql, v)
+        if @opts[:bind_vars] and match = /\A\$(.*)\z/.match(v.to_s)
+          s = match[1].split('__')[0].to_sym
+          if prepared_arg?(s)
+            literal_append(sql, prepared_arg(s))
+          else
+            sql << v.to_s
+          end
+        else
+          super
+        end
+      end
+      @c[1].should == @p
+      @db.sqls.should == ["SELECT * FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
+    end 
+  end
+end

data/spec/extensions/prepared_statements_with_pk_spec.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "prepared_statements_with_pk plugin" do
+  before do
+    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
+    @c = Class.new(Sequel::Model(@db[:people]))
+    @c.columns :id, :name, :i
+    @c.plugin :prepared_statements_with_pk
+    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
+    @db.sqls
+  end
+
+  specify "should load the prepared_statements plugin" do
+    @c.plugins.should include(Sequel::Plugins::PreparedStatements)
+  end
+
+  specify "should correctly lookup by primary key from dataset" do
+    @c.dataset.filter(:name=>'foo')[1].should == @p
+    @c.db.sqls.should == ["SELECT * FROM people WHERE ((name = 'foo') AND (people.id = 1)) LIMIT 1 -- read_only"]
+  end
+
+  specify "should still work correctly if there are multiple conflicting variables" do
+    @c.dataset.filter(:name=>'foo').or(:name=>'bar')[1].should == @p
+    @c.db.sqls.should == ["SELECT * FROM people WHERE (((name = 'foo') OR (name = 'bar')) AND (people.id = 1)) LIMIT 1 -- read_only"]
+  end
+
+  specify "should still work correctly if the primary key is used elsewhere in the query" do
+    @c.dataset.filter{id > 2}[1].should == @p
+    @c.db.sqls.should == ["SELECT * FROM people WHERE ((id > 2) AND (people.id = 1)) LIMIT 1 -- read_only"]
+  end
+end

data/spec/extensions/pretty_table_spec.rb

@@ -7,12 +7,7 @@ describe "Dataset#print" do
     @output = StringIO.new
     @orig_stdout = $stdout
     $stdout = @output
-    @dataset = Sequel::Dataset.new(nil).from(:items)
-    def @dataset.fetch_rows(sql)
-      yield({:a=>1, :b=>2})
-      yield({:a=>3, :b=>4})
-      yield({:a=>5, :b=>6})
-    end
+    @dataset = Sequel.mock(:fetch=>[{:a=>1, :b=>2}, {:a=>3, :b=>4}, {:a=>5, :b=>6}])[:items]
   end
 
   after do
@@ -68,6 +63,12 @@ describe "PrettyTable" do
       /\n(\|x\|y\|)|(\|y\|x\|)\n/
   end
   
+  specify "should have #string return the string without printing" do
+    Sequel::PrettyTable.string(@data1).should =~ /\n(\|x\|y\|)|(\|y\|x\|)\n/
+    @output.rewind
+    @output.read.should == ''
+  end
+  
   specify "should calculate the maximum width of each column correctly" do
     Sequel::PrettyTable.print(@data2, [:a, :b])
     @output.rewind

data/spec/extensions/query_literals_spec.rb

@@ -0,0 +1,167 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "query_literals extension" do
+  before do
+    @ds = Sequel::Dataset.new(nil).from(:t).extension(:query_literals)
+  end
+
+  it "should not use special support if given a block" do
+    @ds.select('a, b, c'){d}.sql.should == 'SELECT \'a, b, c\', d FROM t'
+  end
+
+  it "should have #select use literal string if given a single string" do
+    @ds.select('a, b, c').sql.should == 'SELECT a, b, c FROM t'
+  end
+
+  it "should have #select use placeholder literal string if given a string and additional arguments" do
+    @ds.select('a, b, ?', 1).sql.should == 'SELECT a, b, 1 FROM t'
+  end
+
+  it "should have #select work the standard way if initial string is a literal string already" do
+    @ds.select(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT a, b, ?, 1 FROM t'
+  end
+
+  it "should have #select work regularly if not given a string as the first argument" do
+    @ds.select(:a, 1).sql.should == 'SELECT a, 1 FROM t'
+  end
+
+  describe 'with existing selection' do
+    before do
+      @ds = @ds.select(:d)
+    end
+
+    it "should have #select_more use literal string if given a single string" do
+      @ds.select_more('a, b, c').sql.should == 'SELECT d, a, b, c FROM t'
+    end
+
+    it "should have #select_ use placeholder literal string if given a string and additional arguments" do
+      @ds.select_more('a, b, ?', 1).sql.should == 'SELECT d, a, b, 1 FROM t'
+    end
+
+    it "should have #select_more work the standard way if initial string is a literal string already" do
+      @ds.select_more(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT d, a, b, ?, 1 FROM t'
+    end
+
+    it "should have #select_more work regularly if not given a string as the first argument" do
+      @ds.select_more(:a, 1).sql.should == 'SELECT d, a, 1 FROM t'
+    end
+  end
+
+  it "should have #select_append use literal string if given a single string" do
+    @ds.select_append('a, b, c').sql.should == 'SELECT *, a, b, c FROM t'
+  end
+
+  it "should have #select_append use placeholder literal string if given a string and additional arguments" do
+    @ds.select_append('a, b, ?', 1).sql.should == 'SELECT *, a, b, 1 FROM t'
+  end
+
+  it "should have #select_append work the standard way if initial string is a literal string already" do
+    @ds.select_append(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT *, a, b, ?, 1 FROM t'
+  end
+
+  it "should have #select_append work regularly if not given a string as the first argument" do
+    @ds.select_append(:a, 1).sql.should == 'SELECT *, a, 1 FROM t'
+  end
+
+  it "should have #select_group use literal string if given a single string" do
+    @ds.select_group('a, b, c').sql.should == 'SELECT a, b, c FROM t GROUP BY a, b, c'
+  end
+
+  it "should have #select_group use placeholder literal string if given a string and additional arguments" do
+    @ds.select_group('a, b, ?', 1).sql.should == 'SELECT a, b, 1 FROM t GROUP BY a, b, 1'
+  end
+
+  it "should have #select_group work the standard way if initial string is a literal string already" do
+    @ds.select_group(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT a, b, ?, 1 FROM t GROUP BY a, b, ?, 1'
+  end
+
+  it "should have #select_group work regularly if not given a string as the first argument" do
+    @ds.select_group(:a, 1).sql.should == 'SELECT a, 1 FROM t GROUP BY a, 1'
+  end
+
+  it "should have #group use literal string if given a single string" do
+    @ds.group('a, b, c').sql.should == 'SELECT * FROM t GROUP BY a, b, c'
+  end
+
+  it "should have #group use placeholder literal string if given a string and additional arguments" do
+    @ds.group('a, b, ?', 1).sql.should == 'SELECT * FROM t GROUP BY a, b, 1'
+  end
+
+  it "should have #group work the standard way if initial string is a literal string already" do
+    @ds.group(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT * FROM t GROUP BY a, b, ?, 1'
+  end
+
+  it "should have #group work regularly if not given a string as the first argument" do
+    @ds.group(:a, 1).sql.should == 'SELECT * FROM t GROUP BY a, 1'
+  end
+
+  it "should have #group_and_count use literal string if given a single string" do
+    @ds.group_and_count('a, b, c').sql.should == 'SELECT a, b, c, count(*) AS count FROM t GROUP BY a, b, c'
+  end
+
+  it "should have #group_and_count use placeholder literal string if given a string and additional arguments" do
+    @ds.group_and_count('a, b, ?', 1).sql.should == 'SELECT a, b, 1, count(*) AS count FROM t GROUP BY a, b, 1'
+  end
+
+  it "should have #group_and_count work the standard way if initial string is a literal string already" do
+    @ds.group_and_count(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT a, b, ?, 1, count(*) AS count FROM t GROUP BY a, b, ?, 1'
+  end
+
+  it "should have #group_and_count work regularly if not given a string as the first argument" do
+    @ds.group_and_count(:a, 1).sql.should == 'SELECT a, 1, count(*) AS count FROM t GROUP BY a, 1'
+  end
+
+  it "should have #order use literal string if given a single string" do
+    @ds.order('a, b, c').sql.should == 'SELECT * FROM t ORDER BY a, b, c'
+  end
+
+  it "should have #order use placeholder literal string if given a string and additional arguments" do
+    @ds.order('a, b, ?', 1).sql.should == 'SELECT * FROM t ORDER BY a, b, 1'
+  end
+
+  it "should have #order work the standard way if initial string is a literal string already" do
+    @ds.order(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT * FROM t ORDER BY a, b, ?, 1'
+  end
+
+  it "should have #order work regularly if not given a string as the first argument" do
+    @ds.order(:a, 1).sql.should == 'SELECT * FROM t ORDER BY a, 1'
+  end
+
+  describe 'with existing order' do
+    before do
+      @ds = @ds.order(:d)
+    end
+
+    it "should have #order_more use literal string if given a single string" do
+      @ds.order_more('a, b, c').sql.should == 'SELECT * FROM t ORDER BY d, a, b, c'
+    end
+
+    it "should have #order_more use placeholder literal string if given a string and additional arguments" do
+      @ds.order_more('a, b, ?', 1).sql.should == 'SELECT * FROM t ORDER BY d, a, b, 1'
+    end
+
+    it "should have #order_more work the standard way if initial string is a literal string already" do
+      @ds.order_more(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT * FROM t ORDER BY d, a, b, ?, 1'
+    end
+
+    it "should have #order_more work regularly if not given a string as the first argument" do
+      @ds.order_more(:a, 1).sql.should == 'SELECT * FROM t ORDER BY d, a, 1'
+    end
+
+    it "should have #order_prepend use literal string if given a single string" do
+      @ds.order_prepend('a, b, c').sql.should == 'SELECT * FROM t ORDER BY a, b, c, d'
+    end
+
+    it "should have #order_append use placeholder literal string if given a string and additional arguments" do
+      @ds.order_prepend('a, b, ?', 1).sql.should == 'SELECT * FROM t ORDER BY a, b, 1, d'
+    end
+
+    it "should have #order_append work the standard way if initial string is a literal string already" do
+      @ds.order_prepend(Sequel.lit('a, b, ?'), 1).sql.should == 'SELECT * FROM t ORDER BY a, b, ?, 1, d'
+    end
+
+    it "should have #order_append work regularly if not given a string as the first argument" do
+      @ds.order_prepend(:a, 1).sql.should == 'SELECT * FROM t ORDER BY a, 1, d'
+    end
+  end
+end

data/spec/extensions/query_spec.rb

@@ -17,6 +17,12 @@ describe "Dataset#query" do
     @d = Sequel::Dataset.new(nil)
   end
   
+  specify "should allow cloning without arguments" do
+    q = @d.query {clone}
+    q.class.should == @d.class
+    q.sql.should == "SELECT *"
+  end
+  
   specify "should support #from" do
     q = @d.query {from :xxx}
     q.class.should == @d.class
@@ -35,13 +41,13 @@ describe "Dataset#query" do
   specify "should support #where" do
     q = @d.query do
       from :zzz
-      where(:x + 2 > :y + 3)
+      where{x + 2 > Sequel.expr(:y) + 3}
     end
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM zzz WHERE ((x + 2) > (y + 3))"
 
     q = @d.from(:zzz).query do
-      where((:x.sql_number > 1) & (:y.sql_number > 2))
+      where{(x > 1) & (Sequel.expr(:y) > 2)}
     end
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM zzz WHERE ((x > 1) AND (y > 2))"
@@ -57,7 +63,7 @@ describe "Dataset#query" do
     q = @d.query do
       from :abc
       group_by :id
-      having(:x.sql_number >= 2)
+      having{x >= 2}
     end
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM abc GROUP BY id HAVING (x >= 2)"