sequel 3.33.0 → 3.34.0

data/spec/adapters/spec_helper.rb

@@ -14,6 +14,8 @@ if ENV['SEQUEL_COLUMNS_INTROSPECTION']
   Sequel::Dataset.introspect_all_columns
 end
 
+Sequel::Model.cache_anonymous_models = false
+
 class Sequel::Database
   def log_duration(duration, message)
     log_info(message)

data/spec/adapters/sqlite_spec.rb

@@ -78,7 +78,7 @@ describe "An SQLite database" do
   end
   
   specify "should provide a list of existing tables" do
-    @db.drop_table(:testing) rescue nil
+    @db.drop_table?(:testing)
     @db.tables.should be_a_kind_of(Array)
     @db.tables.should_not include(:testing)
     @db.create_table! :testing do
@@ -145,12 +145,12 @@ describe "SQLite type conversion" do
     @integer_booleans = @db.integer_booleans
     @db.integer_booleans = true
     @ds = @db[:items]
-    @db.drop_table(:items) rescue nil
+    @db.drop_table?(:items)
   end
   after do
     @db.integer_booleans = @integer_booleans
     Sequel.datetime_class = Time
-    @db.drop_table(:items)
+    @db.drop_table?(:items)
   end
   
   specify "should handle integers in boolean columns" do
@@ -352,7 +352,7 @@ describe "SQLite dataset" do
     @d << {:name => 'ghi', :value => 7.89}
   end
   after do
-    SQLITE_DB.drop_table(:test, :items)
+    SQLITE_DB.drop_table?(:test, :items)
   end
   
   specify "should be able to insert from a subquery" do
@@ -363,13 +363,13 @@ describe "SQLite dataset" do
   end
     
   specify "should support #explain" do
-    SQLITE_DB[:test].explain.should be_a_kind_of(Array)
+    SQLITE_DB[:test].explain.should be_a_kind_of(String)
   end
   
   specify "should have #explain work when identifier_output_method is modified" do
     ds = SQLITE_DB[:test]
     ds.identifier_output_method = :upcase
-    ds.explain.should be_a_kind_of(Array)
+    ds.explain.should be_a_kind_of(String)
   end
 end
 
@@ -457,7 +457,7 @@ describe "A SQLite database" do
       @db[:test].filter(:name => 'foo').update(:id=>100)
       @db[:test3][:name => 'abc'][:test_id].should == 100
 
-      @db.drop_table :test, :test3
+      @db.drop_table? :test, :test3
     end
   end
 
@@ -495,7 +495,7 @@ describe "A SQLite database" do
   specify "should handle quoted tables when dropping or renaming columns" do
     @db.quote_identifiers = true
     table_name = "T T"
-    @db.drop_table(table_name) rescue nil
+    @db.drop_table?(table_name)
     @db.create_table! table_name do
       Integer :"s s"
       Integer :"i i"

data/spec/core/connection_pool_spec.rb

@@ -228,6 +228,45 @@ describe "A connection pool with a max size of 1" do
 end
 
 shared_examples_for "A threaded connection pool" do  
+  specify "should not have all_connections yield connections allocated to other threads" do
+    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>2, :pool_timeout=>0)) {@invoked_count += 1}
+    q, q1 = Queue.new, Queue.new
+    t = Thread.new do
+      pool.hold do |c1|
+        q1.push nil
+        q.pop
+      end
+    end
+    pool.hold do |c1|
+      q1.pop
+      pool.all_connections{|c| c.should == c1}
+      q.push nil
+    end
+    t.join
+  end
+
+  specify "should not have all_connections yield all available connections" do
+    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>2, :pool_timeout=>0)){@invoked_count += 1}
+    q, q1 = Queue.new, Queue.new
+    b = []
+    t = Thread.new do
+      pool.hold do |c1|
+        b << c1
+        q1.push nil
+        q.pop
+      end
+    end
+    pool.hold do |c1|
+      q1.pop
+      b << c1
+      q.push nil
+    end
+    t.join
+    a = []
+    pool.all_connections{|c| a << c}
+    a.sort.should == b.sort
+  end
+
   specify "should raise a PoolTimeout error if a connection couldn't be acquired before timeout" do
     x = nil
     q, q1 = Queue.new, Queue.new
@@ -370,6 +409,16 @@ describe "A connection pool with multiple servers" do
     @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
   end
   
+  specify "#all_connections should return connections for all servers" do
+    @pool.hold{}
+    @pool.all_connections{|c1| c1.should == "default1"}
+    a = []
+    @pool.hold(:read_only) do |c|
+      @pool.all_connections{|c1| a << c1}
+    end
+    a.sort_by{|c| c.to_s}.should == ["default1", "read_only1"]
+  end
+  
   specify "#servers should return symbols for all servers" do
     @pool.servers.sort_by{|s| s.to_s}.should == [:default, :read_only]
   end
@@ -624,6 +673,16 @@ describe "A single threaded pool with multiple servers" do
     @pool = Sequel::ConnectionPool.get_pool(ST_CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3}, :servers=>{:read_only=>{}})){|server| server}
   end
   
+  specify "#all_connections should return connections for all servers" do
+    @pool.hold{}
+    @pool.all_connections{|c1| c1.should == :default}
+    a = []
+    @pool.hold(:read_only) do
+      @pool.all_connections{|c1| a << c1}
+    end
+    a.sort_by{|c| c.to_s}.should == [:default, :read_only]
+  end
+  
   specify "#servers should return symbols for all servers" do
     @pool.servers.sort_by{|s| s.to_s}.should == [:default, :read_only]
   end
@@ -730,6 +789,32 @@ describe "A single threaded pool with multiple servers" do
 end
 
 shared_examples_for "All connection pools classes" do
+  specify "should have all_connections yield current and available connections" do
+    p = @class.new({}){123}
+    p.hold{|c| p.all_connections{|c1| c.should == c1}}
+  end
+
+  specify "should be able to modify after_connect proc after the pool is created" do
+    a = []
+    p = @class.new({}){123}
+    p.after_connect = pr = proc{|c| a << c}
+    p.after_connect.should == pr
+    a.should == []
+    p.hold{}
+    a.should == [123]
+  end
+
+  specify "should be able to modify disconnection_proc after the pool is created" do
+    a = []
+    p = @class.new({}){123}
+    p.disconnection_proc = pr = proc{|c| a << c}
+    p.disconnection_proc.should == pr
+    p.hold{}
+    a.should == []
+    p.disconnect
+    a.should == [123]
+  end
+
   specify "should not raise an error when disconnecting twice" do
     c = @class.new({}){123}
     proc{c.disconnect}.should_not raise_error

data/spec/core/database_spec.rb

@@ -325,6 +325,10 @@ describe "Database#uri" do
     @db.uri.should == 'mau://user:pass@localhost:9876/maumau'
   end
   
+  specify "should return nil if a connection uri was not used" do
+    Sequel.mock.uri.should be_nil
+  end
+  
   specify "should be aliased as #url" do
     @db.url.should == 'mau://user:pass@localhost:9876/maumau'
   end
@@ -413,6 +417,13 @@ describe "Database#extend_datasets" do
     @db.extend_datasets(@m)
   end
   
+  specify "should clear a cached dataset" do
+    @db = Sequel::Database.new
+    @db.literal(1).should == '1'
+    @db.extend_datasets{def literal(v) '2' end}
+    @db.literal(1).should == '2'
+  end
+
   specify "should change the dataset class to a subclass the first time it is called" do
     @db.dataset_class.superclass.should == Sequel::Dataset
   end
@@ -484,6 +495,12 @@ describe "Database#indexes" do
   end
 end
 
+describe "Database#foreign_key_list" do
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.foreign_key_list(:table)}.should raise_error(Sequel::NotImplemented)
+  end
+end
+
 describe "Database#run" do
   before do
     @db = Sequel.mock(:servers=>{:s1=>{}})
@@ -1061,21 +1078,20 @@ describe "A Database adapter with a scheme" do
     proc {Sequel.ccc('abc', 'def')}.should raise_error(Sequel::Error)
     
     c = Sequel.ccc('mydb')
-    p = proc{c.opts.delete_if{|k,v| k == :disconnection_proc || k == :single_threaded}}
     c.should be_a_kind_of(@ccc)
-    p.call.should == {:adapter=>:ccc, :database => 'mydb', :adapter_class=>@ccc}
+    c.opts.values_at(:adapter, :database, :adapter_class).should == [:ccc, 'mydb', @ccc]
     
     c = Sequel.ccc('mydb', :host => 'localhost')
     c.should be_a_kind_of(@ccc)
-    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost', :adapter_class=>@ccc}
+    c.opts.values_at(:adapter, :database, :host, :adapter_class).should == [:ccc, 'mydb', 'localhost', @ccc]
     
     c = Sequel.ccc
     c.should be_a_kind_of(@ccc)
-    p.call.should == {:adapter=>:ccc, :adapter_class=>@ccc}
+    c.opts.values_at(:adapter, :adapter_class).should == [:ccc, @ccc]
     
     c = Sequel.ccc(:database => 'mydb', :host => 'localhost')
     c.should be_a_kind_of(@ccc)
-    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost', :adapter_class=>@ccc}
+    c.opts.values_at(:adapter, :database, :host, :adapter_class).should == [:ccc, 'mydb', 'localhost', @ccc]
   end
   
   specify "should be accessible through Sequel.connect with options" do
@@ -1336,6 +1352,14 @@ describe "Database#inspect" do
   specify "should include the class name and the connection url" do
     Sequel.connect('mock://foo/bar').inspect.should == '#<Sequel::Mock::Database: "mock://foo/bar">'
   end
+
+  specify "should include the class name and the connection options if an options hash was given" do
+    Sequel.connect(:adapter=>:mock).inspect.should =~ /#<Sequel::Mock::Database: \{:adapter=>:mock\}>/
+  end
+
+  specify "should include the class name, uri, and connection options if uri and options hash was given" do
+    Sequel.connect('mock://foo', :database=>'bar').inspect.should =~ /#<Sequel::Mock::Database: "mock:\/\/foo" \{:database=>"bar"\}>/
+  end
 end
 
 describe "Database#get" do

data/spec/core/dataset_spec.rb

@@ -914,12 +914,18 @@ describe "Dataset#group_by" do
     @dataset.meta_def(:supports_group_rollup?){true}
     @dataset.group(:type_id).group_rollup.select_sql.should == "SELECT * FROM test GROUP BY ROLLUP(type_id)"
     @dataset.group(:type_id, :b).group_rollup.select_sql.should == "SELECT * FROM test GROUP BY ROLLUP(type_id, b)"
+    @dataset.meta_def(:uses_with_rollup?){true}
+    @dataset.group(:type_id).group_rollup.select_sql.should == "SELECT * FROM test GROUP BY type_id WITH ROLLUP"
+    @dataset.group(:type_id, :b).group_rollup.select_sql.should == "SELECT * FROM test GROUP BY type_id, b WITH ROLLUP"
   end
 
   specify "should support a #group_cube method if the database supports it" do
     @dataset.meta_def(:supports_group_cube?){true}
     @dataset.group(:type_id).group_cube.select_sql.should == "SELECT * FROM test GROUP BY CUBE(type_id)"
     @dataset.group(:type_id, :b).group_cube.select_sql.should == "SELECT * FROM test GROUP BY CUBE(type_id, b)"
+    @dataset.meta_def(:uses_with_rollup?){true}
+    @dataset.group(:type_id).group_cube.select_sql.should == "SELECT * FROM test GROUP BY type_id WITH CUBE"
+    @dataset.group(:type_id, :b).group_cube.select_sql.should == "SELECT * FROM test GROUP BY type_id, b WITH CUBE"
   end
 
   specify "should have #group_cube and #group_rollup methods raise an Error if not supported it" do
@@ -935,6 +941,42 @@ describe "Dataset#as" do
   end
 end
 
+describe "Dataset#literal" do
+  before do
+    @ds = Sequel::Database.new.dataset
+  end
+  
+  specify "should convert qualified symbol notation into dot notation" do
+    @ds.literal(:abc__def).should == 'abc.def'
+  end
+  
+  specify "should convert AS symbol notation into SQL AS notation" do
+    @ds.literal(:xyz___x).should == 'xyz AS x'
+    @ds.literal(:abc__def___x).should == 'abc.def AS x'
+  end
+  
+  specify "should support names with digits" do
+    @ds.literal(:abc2).should == 'abc2'
+    @ds.literal(:xx__yy3).should == 'xx.yy3'
+    @ds.literal(:ab34__temp3_4ax).should == 'ab34.temp3_4ax'
+    @ds.literal(:x1___y2).should == 'x1 AS y2'
+    @ds.literal(:abc2__def3___ggg4).should == 'abc2.def3 AS ggg4'
+  end
+  
+  specify "should support upper case and lower case" do
+    @ds.literal(:ABC).should == 'ABC'
+    @ds.literal(:Zvashtoy__aBcD).should == 'Zvashtoy.aBcD'
+  end
+
+  specify "should support spaces inside column names" do
+    @ds.quote_identifiers = true
+    @ds.literal(:"AB C").should == '"AB C"'
+    @ds.literal(:"Zvas htoy__aB cD").should == '"Zvas htoy"."aB cD"'
+    @ds.literal(:"aB cD___XX XX").should == '"aB cD" AS "XX XX"'
+    @ds.literal(:"Zva shtoy__aB cD___XX XX").should == '"Zva shtoy"."aB cD" AS "XX XX"'
+  end
+end
+
 describe "Dataset#literal" do
   before do
     @dataset = Sequel::Database.new.from(:test)
@@ -1105,6 +1147,17 @@ describe "Dataset#literal" do
     @dataset.literal(BigDecimal.new("-Infinity")).should == "'-Infinity'"
   end
 
+  specify "should literalize PlaceholderLiteralStrings correctly" do
+    @dataset.literal(Sequel::SQL::PlaceholderLiteralString.new('? = ?', [1, 2])).should == '1 = 2'
+    @dataset.literal(Sequel::SQL::PlaceholderLiteralString.new('? = ?', [1, 2], true)).should == '(1 = 2)'
+    @dataset.literal(Sequel::SQL::PlaceholderLiteralString.new(':a = :b', :a=>1, :b=>2)).should == '1 = 2'
+    @dataset.literal(Sequel::SQL::PlaceholderLiteralString.new(':a = :b', {:a=>1, :b=>2}, true)).should == '(1 = 2)'
+    @dataset.literal(Sequel::SQL::PlaceholderLiteralString.new(['', ' = ', ''], [1, 2])).should == '1 = 2'
+    @dataset.literal(Sequel::SQL::PlaceholderLiteralString.new(['', ' = ', ''], [1, 2], true)).should == '(1 = 2)'
+    @dataset.literal(Sequel::SQL::PlaceholderLiteralString.new(['', ' = '], [1, 2])).should == '1 = 2'
+    @dataset.literal(Sequel::SQL::PlaceholderLiteralString.new(['', ' = '], [1, 2], true)).should == '(1 = 2)'
+  end
+
   specify "should raise an Error if the object can't be literalized" do
     proc{@dataset.literal(Object.new)}.should raise_error(Sequel::Error)
   end
@@ -1720,7 +1773,45 @@ describe "Dataset#to_hash" do
     @d.to_hash(:b).should == {4 => {:a => 2, :b => 4}, 8 => {:a => 6, :b => 8}, 12 => {:a => 10, :b => 12}}
     @d.to_hash([:a, :b]).should == {[2, 4] => {:a => 2, :b => 4}, [6, 8] => {:a => 6, :b => 8}, [10, 12] => {:a => 10, :b => 12}}
   end
+end
+
+describe "Dataset#to_hash_groups" do
+  before do
+    @d = Sequel.mock(:fetch=>[{:a => 1, :b => 2}, {:a => 3, :b => 4}, {:a => 1, :b => 6}, {:a => 7, :b => 4}])[:items]
+  end
   
+  specify "should provide a hash with the first column as key and the second as value" do
+    @d.to_hash_groups(:a, :b).should == {1 => [2, 6], 3 => [4], 7 => [4]}
+    @d.to_hash_groups(:b, :a).should == {2 => [1], 4=>[3, 7], 6=>[1]}
+  end
+  
+  specify "should provide a hash with the first column as key and the entire hash as value if the value column is blank or nil" do
+    @d.to_hash_groups(:a).should == {1 => [{:a => 1, :b => 2}, {:a => 1, :b => 6}], 3 => [{:a => 3, :b => 4}], 7 => [{:a => 7, :b => 4}]}
+    @d.to_hash_groups(:b).should == {2 => [{:a => 1, :b => 2}], 4 => [{:a => 3, :b => 4}, {:a => 7, :b => 4}], 6 => [{:a => 1, :b => 6}]}
+  end
+
+  specify "should support using an array of columns as either the key or the value" do
+    @d.to_hash_groups([:a, :b], :b).should == {[1, 2] => [2], [3, 4] => [4], [1, 6] => [6], [7, 4]=>[4]}
+    @d.to_hash_groups(:b, [:a, :b]).should == {2 => [[1, 2]], 4 => [[3, 4], [7, 4]], 6 => [[1, 6]]}
+    @d.to_hash_groups([:b, :a], [:a, :b]).should == {[2, 1] => [[1, 2]], [4, 3] => [[3, 4]], [6, 1] => [[1, 6]], [4, 7]=>[[7, 4]]}
+    @d.to_hash_groups([:a, :b]).should == {[1, 2] => [{:a => 1, :b => 2}], [3, 4] => [{:a => 3, :b => 4}], [1, 6] => [{:a => 1, :b => 6}], [7, 4] => [{:a => 7, :b => 4}]}
+  end
+
+  specify "should not call the row_proc if two arguments are given" do
+    @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
+    @d.to_hash_groups(:a, :b).should == {1 => [2, 6], 3 => [4], 7 => [4]}
+    @d.to_hash_groups(:b, :a).should == {2 => [1], 4=>[3, 7], 6=>[1]}
+    @d.to_hash_groups([:a, :b], :b).should == {[1, 2] => [2], [3, 4] => [4], [1, 6] => [6], [7, 4]=>[4]}
+    @d.to_hash_groups(:b, [:a, :b]).should == {2 => [[1, 2]], 4 => [[3, 4], [7, 4]], 6 => [[1, 6]]}
+    @d.to_hash_groups([:b, :a], [:a, :b]).should == {[2, 1] => [[1, 2]], [4, 3] => [[3, 4]], [6, 1] => [[1, 6]], [4, 7]=>[[7, 4]]}
+  end
+
+  specify "should call the row_proc if only a single argument is given" do
+    @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
+    @d.to_hash_groups(:a).should == {2 => [{:a => 2, :b => 4}, {:a => 2, :b => 12}], 6 => [{:a => 6, :b => 8}], 14 => [{:a => 14, :b => 8}]}
+    @d.to_hash_groups(:b).should == {4 => [{:a => 2, :b => 4}], 8 => [{:a => 6, :b => 8}, {:a => 14, :b => 8}], 12 => [{:a => 2, :b => 12}]}
+    @d.to_hash_groups([:a, :b]).should == {[2, 4] => [{:a => 2, :b => 4}], [6, 8] => [{:a => 6, :b => 8}], [2, 12] => [{:a => 2, :b => 12}], [14, 8] => [{:a => 14, :b => 8}]}
+  end
 end
 
 describe "Dataset#distinct" do
@@ -3077,7 +3168,7 @@ describe "Dataset#grep" do
   end
 end
 
-describe "Dataset default #fetch_rows, #insert, #update, #delete, #truncate, #execute" do
+describe "Dataset default #fetch_rows, #insert, #update, #delete, #with_sql_delete, #truncate, #execute" do
   before do
     @db = Sequel::Database.new
     @ds = @db[:items]
@@ -3094,6 +3185,14 @@ describe "Dataset default #fetch_rows, #insert, #update, #delete, #truncate, #ex
     @ds.delete
   end
 
+  specify "#with_sql_delete should execute delete SQL" do
+    sql = 'DELETE FROM foo'
+    @db.should_receive(:execute).once.with(sql, :server=>:default)
+    @ds.with_sql_delete(sql)
+    @db.should_receive(:execute_dui).once.with(sql, :server=>:default)
+    @ds.with_sql_delete(sql)
+  end
+
   specify "#insert should execute insert SQL" do
     @db.should_receive(:execute).once.with('INSERT INTO items DEFAULT VALUES', :server=>:default)
     @ds.insert([])
@@ -3136,12 +3235,14 @@ describe "Dataset prepared statements and bound variables " do
     @ds.filter(:num=>:$n).call(:select, :n=>1)
     @ds.filter(:num=>:$n).call([:map, :a], :n=>1)
     @ds.filter(:num=>:$n).call([:to_hash, :a, :b], :n=>1)
+    @ds.filter(:num=>:$n).call([:to_hash_groups, :a, :b], :n=>1)
     @ds.filter(:num=>:$n).call(:first, :n=>1)
     @ds.filter(:num=>:$n).call(:delete, :n=>1)
     @ds.filter(:num=>:$n).call(:update, {:n=>1, :n2=>2}, :num=>:$n2)
     @ds.call(:insert, {:n=>1}, :num=>:$n)
     @ds.call(:insert_select, {:n=>1}, :num=>:$n)
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1) LIMIT 1',
@@ -3156,22 +3257,25 @@ describe "Dataset prepared statements and bound variables " do
     pss << @ds.filter(:num=>:$n).prepare(:select, :sn)
     pss << @ds.filter(:num=>:$n).prepare([:map, :a], :sm)
     pss << @ds.filter(:num=>:$n).prepare([:to_hash, :a, :b], :sh)
+    pss << @ds.filter(:num=>:$n).prepare([:to_hash_groups, :a, :b], :shg)
     pss << @ds.filter(:num=>:$n).prepare(:first, :fn)
     pss << @ds.filter(:num=>:$n).prepare(:delete, :dn)
     pss << @ds.filter(:num=>:$n).prepare(:update, :un, :num=>:$n2)
     pss << @ds.prepare(:insert, :in, :num=>:$n)
     pss << @ds.prepare(:insert_select, :ins, :num=>:$n)
-    @db.prepared_statements.keys.sort_by{|k| k.to_s}.should == [:dn, :fn, :in, :ins, :sh, :sm, :sn, :un]
-    [:sn, :sm, :sh, :fn, :dn, :un, :in, :ins].each_with_index{|x, i| @db.prepared_statements[x].should == pss[i]}
+    @db.prepared_statements.keys.sort_by{|k| k.to_s}.should == [:dn, :fn, :in, :ins, :sh, :shg, :sm, :sn, :un]
+    [:sn, :sm, :sh, :shg, :fn, :dn, :un, :in, :ins].each_with_index{|x, i| @db.prepared_statements[x].should == pss[i]}
     @db.call(:sn, :n=>1)
     @db.call(:sm, :n=>1)
     @db.call(:sh, :n=>1)
+    @db.call(:shg, :n=>1)
     @db.call(:fn, :n=>1)
     @db.call(:dn, :n=>1)
     @db.call(:un, :n=>1, :n2=>2)
     @db.call(:in, :n=>1)
     @db.call(:ins, :n=>1)
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1) LIMIT 1',
@@ -3427,6 +3531,10 @@ describe "Sequel::Dataset#qualify_to_first_source" do
     @ds.filter(':a > :b', :a=>:c, :b=>1).qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE (t.c > 1)'
   end
 
+  specify "should handle SQL::Wrappers" do
+    @ds.filter(Sequel::SQL::Wrapper.new(:a)).qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE t.a'
+  end
+
   specify "should handle SQL::WindowFunctions" do
     @ds.meta_def(:supports_window_functions?){true}
     @ds.select{sum(:over, :args=>:a, :partition=>:b, :order=>:c){}}.qualify_to_first_source.sql.should == 'SELECT sum(t.a) OVER (PARTITION BY t.b ORDER BY t.c) FROM t'
@@ -3485,6 +3593,10 @@ describe "Sequel::Dataset#unbind" do
     @u[@ds.filter{foo__bar > 1}].should == ["SELECT * FROM t WHERE (foo.bar > $foo.bar)", {:"foo.bar"=>1}]
   end
 
+  specify "should handle wrapped objects" do
+    @u[@ds.filter{Sequel::SQL::Wrapper.new(foo__bar) > Sequel::SQL::Wrapper.new(1)}].should == ["SELECT * FROM t WHERE (foo.bar > $foo.bar)", {:"foo.bar"=>1}]
+  end
+
   specify "should handle deep nesting" do
     @u[@ds.filter{foo > 1}.and{bar < 2}.or(:baz=>3).and({~{:x=>4}=>true}.case(false))].should == ["SELECT * FROM t WHERE ((((foo > $foo) AND (bar < $bar)) OR (baz = $baz)) AND (CASE WHEN (x != $x) THEN 't' ELSE 'f' END))", {:foo=>1, :bar=>2, :baz=>3, :x=>4}]
   end
@@ -3972,6 +4084,62 @@ describe "Sequel::Dataset#select_hash" do
   end
 end
 
+describe "Sequel::Dataset#select_hash_groups" do
+  before do
+    @db = Sequel.mock(:fetch=>[{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+    @ds = @db[:t]
+  end
+
+  specify "should do select and to_hash in one step" do
+    @ds.select_hash_groups(:a, :b).should == {1=>[2], 3=>[4]}
+    @ds.db.sqls.should == ['SELECT a, b FROM t']
+  end
+
+  specify "should handle implicit qualifiers in arguments" do
+    @ds.select_hash_groups(:t__a, :t__b).should == {1=>[2], 3=>[4]}
+    @ds.db.sqls.should == ['SELECT t.a, t.b FROM t']
+  end
+
+  specify "should handle implicit aliases in arguments" do
+    @ds.select_hash_groups(:c___a, :d___b).should == {1=>[2], 3=>[4]}
+    @ds.db.sqls.should == ['SELECT c AS a, d AS b FROM t']
+  end
+
+  specify "should handle implicit qualifiers and aliases in arguments" do
+    @ds.select_hash_groups(:t__c___a, :t__d___b).should == {1=>[2], 3=>[4]}
+    @ds.db.sqls.should == ['SELECT t.c AS a, t.d AS b FROM t']
+  end
+
+  specify "should handle SQL::Identifiers in arguments" do
+    @ds.select_hash_groups(:a.identifier, :b.identifier).should == {1=>[2], 3=>[4]}
+    @ds.db.sqls.should == ['SELECT a, b FROM t']
+  end
+
+  specify "should handle SQL::QualifiedIdentifiers in arguments" do
+    @ds.select_hash_groups(:a.qualify(:t), :b.identifier.qualify(:t)).should == {1=>[2], 3=>[4]}
+    @ds.db.sqls.should == ['SELECT t.a, t.b FROM t']
+  end
+
+  specify "should handle SQL::AliasedExpressions in arguments" do
+    @ds.select_hash_groups(:c.as(:a), :t.as(:b)).should == {1=>[2], 3=>[4]}
+    @ds.db.sqls.should == ['SELECT c AS a, t AS b FROM t']
+  end
+
+  specify "should work with arrays of columns" do
+    @db.fetch = [{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}]
+    @ds.select_hash_groups([:a, :c], :b).should == {[1, 3]=>[2], [4, 6]=>[5]}
+    @ds.db.sqls.should == ['SELECT a, c, b FROM t']
+    @ds.select_hash_groups(:a, [:b, :c]).should == {1=>[[2, 3]], 4=>[[5, 6]]}
+    @ds.db.sqls.should == ['SELECT a, b, c FROM t']
+    @ds.select_hash_groups([:a, :b], [:b, :c]).should == {[1, 2]=>[[2, 3]], [4, 5]=>[[5, 6]]}
+    @ds.db.sqls.should == ['SELECT a, b, b, c FROM t']
+  end
+
+  specify "should raise an error if the resulting symbol cannot be determined" do
+    proc{@ds.select_hash_groups(:c.as(:a), :b.sql_function)}.should raise_error(Sequel::Error)
+  end
+end
+
 describe "Modifying joined datasets" do
   before do
     @ds = Sequel.mock.from(:b, :c).join(:d, [:id]).where(:id => 2)