sequel 4.11.0 → 4.12.0

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -53,6 +53,20 @@ module Sequel
           opts.send(:cached_fetch, :prepared_statement) do
             unless opts[:instance_specific]
               ds, bv = _associated_dataset(opts, {}).unbind
+
+              f = ds.opts[:from]
+              if f && f.length == 1
+                s = ds.opts[:select]
+                if ds.opts[:join]
+                  if opts.eager_loading_use_associated_key? && s && s.length == 1 && s.first.is_a?(SQL::ColumnAll)
+                    table = s.first.table
+                    ds = ds.select(*opts.associated_class.columns.map{|c| Sequel.identifier(c).qualify(table)})
+                  end
+                elsif !s || s.empty?
+                  ds = ds.select(*opts.associated_class.columns.map{|c| Sequel.identifier(c)})
+                end
+              end 
+          
               if bv.length != assoc_bv.length
                 h = {}
                 bv.each do |k,v|

data/lib/sequel/sql.rb

@@ -1339,16 +1339,6 @@ module Sequel
       end
     end
 
-    # REMOVE411
-    class EmulatedFunction < Function
-      def self.new(name, *args)
-        Deprecation.deprecate("Sequel::SQL::EmulatedFunction", "Please use Sequel::SQL::Function.new!(name, args, :emulate=>true) to create an emulated SQL function")
-        Function.new!(name, args, :emulate=>true)
-      end
-
-      to_s_method :emulated_function_sql
-    end
-    
     class GenericExpression
       include AliasMethods
       include BooleanMethods
@@ -1394,18 +1384,9 @@ module Sequel
       attr_reader :table_expr
 
       # Create an object with the given join_type and table expression.
-      def initialize(join_type, table, table_alias = nil)
+      def initialize(join_type, table_expr)
         @join_type = join_type
-
-        @table_expr = if table.is_a?(AliasedExpression)
-          table
-        # REMOVE411
-        elsif table_alias
-          Deprecation.deprecate("The table_alias argument to Sequel::SQL::JoinClause#initialize", "Please use a Sequel::SQL::AliasedExpression as the table argument instead.")
-          AliasedExpression.new(table, table_alias)
-        else
-          table
-        end
+        @table_expr = table_expr
       end
 
       # The table/set related to the JOIN, without any alias.
@@ -1827,28 +1808,6 @@ module Sequel
       to_s_method :window_sql, '@opts'
     end
 
-    # REMOVE411
-    class WindowFunction < GenericExpression
-      # The function to use, should be an <tt>SQL::Function</tt>.
-      attr_reader :function
-
-      # The window to use, should be an <tt>SQL::Window</tt>.
-      attr_reader :window
-
-      def self.new(function, window)
-        Deprecation.deprecate("Sequel::SQL::WindowFunction", "Please use Sequel::SQL::Function.new(name, *args).over(...) to create an SQL window function")
-        function.over(window)
-      end
-
-      # Set the function and window.
-      def initialize(function, window)
-        Deprecation.deprecate("Sequel::SQL::WindowFunction", "Please use Sequel::SQL::Function.new(name, *args).over(...) to create an SQL window function")
-        @function, @window = function, window
-      end
-
-      to_s_method :window_function_sql, '@function, @window'
-    end
-
     # A +Wrapper+ is a simple way to wrap an existing object so that it supports
     # the Sequel DSL.
     class Wrapper < GenericExpression

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 11
+  MINOR = 12
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -179,6 +179,19 @@ describe "A PostgreSQL database" do
     @db.server_version.should > 70000
   end
 
+  specify "should create a dataset using the VALUES clause via #values" do
+    @db.values([[1, 2], [3, 4]]).map([:column1, :column2]).should == [[1, 2], [3, 4]]
+  end
+
+  specify "should support ordering and limiting with #values" do
+    @db.values([[1, 2], [3, 4]]).reverse(:column2, :column1).limit(1).map([:column1, :column2]).should == [[3, 4]]
+    @db.values([[1, 2], [3, 4]]).reverse(:column2, :column1).offset(1).map([:column1, :column2]).should == [[1, 2]]
+  end
+
+  specify "should support subqueries with #values" do
+    @db.values([[1, 2]]).from_self.cross_join(@db.values([[3, 4]]).as(:x, [:c1, :c2])).map([:column1, :column2, :c1, :c2]).should == [[1, 2, 3, 4]]
+  end
+
   specify "should respect the :read_only option per-savepoint" do
     proc{@db.transaction{@db.transaction(:savepoint=>true, :read_only=>true){@db[:public__testfk].insert}}}.should raise_error(Sequel::DatabaseError)
     proc{@db.transaction(:auto_savepoint=>true, :read_only=>true){@db.transaction(:read_only=>false){@db[:public__testfk].insert}}}.should raise_error(Sequel::DatabaseError)
@@ -257,6 +270,12 @@ describe "A PostgreSQL database" do
     ds.insert(:id=>1)
     ds.select_map(:id).should == [1]
   end
+
+  specify "should have notice receiver receive notices" do
+    a = nil
+    Sequel.connect(DB.opts.merge(:notice_receiver=>proc{|r| a = r.result_error_message})){|db| db.do("BEGIN\nRAISE WARNING 'foo';\nEND;")}
+    a.should == "WARNING:  foo\n"
+  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && DB.server_version >= 90000
 end
 
 describe "A PostgreSQL database with domain types" do
@@ -1035,6 +1054,18 @@ describe "Postgres::Dataset#insert" do
     @ds.first(:xid=>h[:xid])[:value].should == 10
   end
 
+  specify "should have insert_select respect existing returning clause" do
+    h = @ds.returning(:value___v, :xid___x).insert_select(:value=>10)
+    h[:v].should == 10
+    @ds.first(:xid=>h[:x])[:value].should == 10
+  end
+
+  specify "should have prepared insert_select respect existing returning clause" do
+    h = @ds.returning(:value___v, :xid___x).prepare(:insert_select, :insert_select, :value=>10).call
+    h[:v].should == 10
+    @ds.first(:xid=>h[:x])[:value].should == 10
+  end
+
   specify "should correctly return the inserted record's primary key value" do
     value1 = 10
     id1 = @ds.insert(:value=>value1)
@@ -2466,14 +2497,11 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(h2.merge(h3).keys.length).should == 2
     @ds.get(h1.merge(h3).keys.length).should == 3
 
-    unless [:do].include?(@db.adapter_scheme)
-      # Broken DataObjects thinks operators with ? represent placeholders
-      @ds.get(h1.contain_all(%w'a c')).should == true
-      @ds.get(h1.contain_all(%w'a d')).should == false
+    @ds.get(h1.contain_all(%w'a c')).should == true
+    @ds.get(h1.contain_all(%w'a d')).should == false
 
-      @ds.get(h1.contain_any(%w'a d')).should == true
-      @ds.get(h1.contain_any(%w'e d')).should == false
-    end
+    @ds.get(h1.contain_any(%w'a d')).should == true
+    @ds.get(h1.contain_any(%w'e d')).should == false
 
     @ds.get(h1.contains(h2)).should == true
     @ds.get(h1.contains(h3)).should == false
@@ -2491,18 +2519,16 @@ describe 'PostgreSQL hstore handling' do
 
     @ds.from(Sequel.hstore('a'=>'b', 'c'=>nil).op.each).order(:key).all.should == [{:key=>'a', :value=>'b'}, {:key=>'c', :value=>nil}]
 
-    unless [:do].include?(@db.adapter_scheme)
-      @ds.get(h1.has_key?('c')).should == true
-      @ds.get(h1.include?('c')).should == true
-      @ds.get(h1.key?('c')).should == true
-      @ds.get(h1.member?('c')).should == true
-      @ds.get(h1.exist?('c')).should == true
-      @ds.get(h1.has_key?('d')).should == false
-      @ds.get(h1.include?('d')).should == false
-      @ds.get(h1.key?('d')).should == false
-      @ds.get(h1.member?('d')).should == false
-      @ds.get(h1.exist?('d')).should == false
-    end
+    @ds.get(h1.has_key?('c')).should == true
+    @ds.get(h1.include?('c')).should == true
+    @ds.get(h1.key?('c')).should == true
+    @ds.get(h1.member?('c')).should == true
+    @ds.get(h1.exist?('c')).should == true
+    @ds.get(h1.has_key?('d')).should == false
+    @ds.get(h1.include?('d')).should == false
+    @ds.get(h1.key?('d')).should == false
+    @ds.get(h1.member?('d')).should == false
+    @ds.get(h1.exist?('d')).should == false
 
     @ds.get(h1.hstore.hstore.hstore.keys.length).should == 2
     @ds.get(h1.keys.length).should == 2
@@ -3022,6 +3048,7 @@ describe 'PostgreSQL interval types' do
       ['1 second', '00:00:01', 1, [[:seconds, 1]]],
       ['1 minute', '00:01:00', 60, [[:seconds, 60]]],
       ['1 hour', '01:00:00', 3600, [[:seconds, 3600]]],
+      ['123000 hours', '123000:00:00', 442800000, [[:seconds, 442800000]]],
       ['1 day', '1 day', 86400, [[:days, 1]]],
       ['1 week', '7 days', 86400*7, [[:days, 7]]],
       ['1 month', '1 mon', 86400*30, [[:months, 1]]],
@@ -3390,7 +3417,8 @@ describe 'pg_static_cache_updater extension' do
     q = Queue.new
     q1 = Queue.new
 
-    @db.listen_for_static_cache_updates(@Thing, :timeout=>0, :loop=>proc{q.push(nil); q1.pop.call})
+    @db.listen_for_static_cache_updates(@Thing, :timeout=>0, :loop=>proc{q.push(nil); q1.pop.call}, :before_thread_exit=>proc{q.push(nil)})
+
     q.pop
     q1.push(proc{@db[:things].insert(1, 'A')})
     q.pop
@@ -3405,5 +3433,6 @@ describe 'pg_static_cache_updater extension' do
     @Thing.all.should == []
 
     q1.push(proc{throw :stop})
+    q.pop
   end
 end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && DB.server_version >= 90000

data/spec/bin_spec.rb

@@ -88,8 +88,8 @@ END
     DB2.tables.sort_by{|t| t.to_s}.should == [:a, :b]
     DB[:a].all.should == [{:a=>1, :name=>'foo'}]
     DB[:b].all.should == [{:a=>1}]
-    DB2.schema(:a).should == [[:a, {:allow_null=>false, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}], [:name, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil}]]
-    DB2.schema(:b).should == [[:a, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}]]
+    DB2.schema(:a).map{|col, sch| [col, *sch.values_at(:allow_null, :default, :primary_key, :db_type, :type, :ruby_default)]}.should == [[:a, false, nil, true, "integer", :integer, nil], [:name, true, nil, false, "varchar(255)", :string, nil]]
+    DB2.schema(:b).map{|col, sch| [col, *sch.values_at(:allow_null, :default, :primary_key, :db_type, :type, :ruby_default)]}.should == [[:a, true, nil, false, "integer", :integer, nil]]
     DB2.indexes(:a).should == {}
     DB2.indexes(:b).should == {:b_a_index=>{:unique=>false, :columns=>[:a]}}
     DB2.foreign_key_list(:a).should == []

data/spec/core/dataset_spec.rb

@@ -2127,12 +2127,20 @@ describe "Dataset#join_table" do
     @d.cross_join(:categories).sql.should == 'SELECT * FROM "items" CROSS JOIN "categories"'
   end
   
-  specify "should raise an error if additional arguments are provided to join methods that don't take conditions" do
-    proc{@d.natural_join(:categories, :id=>:id)}.should raise_error(ArgumentError)
-    proc{@d.natural_left_join(:categories, :id=>:id)}.should raise_error(ArgumentError)
-    proc{@d.natural_right_join(:categories, :id=>:id)}.should raise_error(ArgumentError)
-    proc{@d.natural_full_join(:categories, :id=>:id)}.should raise_error(ArgumentError)
-    proc{@d.cross_join(:categories, :id=>:id)}.should raise_error(ArgumentError)
+  specify "should support options hashes for join methods that don't take conditions" do
+    @d.natural_join(:categories, :table_alias=>:a).sql.should == 'SELECT * FROM "items" NATURAL JOIN "categories" AS "a"'
+    @d.natural_left_join(:categories, :table_alias=>:a).sql.should == 'SELECT * FROM "items" NATURAL LEFT JOIN "categories" AS "a"'
+    @d.natural_right_join(:categories, :table_alias=>:a).sql.should == 'SELECT * FROM "items" NATURAL RIGHT JOIN "categories" AS "a"'
+    @d.natural_full_join(:categories, :table_alias=>:a).sql.should == 'SELECT * FROM "items" NATURAL FULL JOIN "categories" AS "a"'
+    @d.cross_join(:categories, :table_alias=>:a).sql.should == 'SELECT * FROM "items" CROSS JOIN "categories" AS "a"'
+  end
+
+  specify "should raise an error if non-hash arguments are provided to join methods that don't take conditions" do
+    proc{@d.natural_join(:categories, nil)}.should raise_error(Sequel::Error)
+    proc{@d.natural_left_join(:categories, nil)}.should raise_error(Sequel::Error)
+    proc{@d.natural_right_join(:categories, nil)}.should raise_error(Sequel::Error)
+    proc{@d.natural_full_join(:categories, nil)}.should raise_error(Sequel::Error)
+    proc{@d.cross_join(:categories, nil)}.should raise_error(Sequel::Error)
   end
 
   specify "should raise an error if blocks are provided to join methods that don't pass them" do
@@ -2184,6 +2192,10 @@ describe "Dataset#join_table" do
     @d.from('stats').join('players', {:id => :player_id}, :implicit_qualifier=>:p).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" ON ("players"."id" = "p"."player_id")'
   end
   
+  specify "should support the :reset_implicit_qualifier option" do
+    @d.from(:stats).join(:a, [:b], :reset_implicit_qualifier=>false).join(:players, {:id => :player_id}).sql.should == 'SELECT * FROM "stats" INNER JOIN "a" USING ("b") INNER JOIN "players" ON ("players"."id" = "stats"."player_id")'
+  end
+  
   specify "should default :qualify option to default_join_table_qualification" do
     def @d.default_join_table_qualification; false; end
     @d.from('stats').join(:players, :id => :player_id).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" ON ("id" = "player_id")'

data/spec/core/schema_spec.rb

@@ -1550,7 +1550,7 @@ describe "Schema Parser" do
   specify "should correctly parse all supported data types" do
     sm = Module.new do
       def schema_parse_table(t, opts)
-        [[:x, {:type=>schema_column_type(t.to_s)}]]
+        [[:x, {:db_type=>t.to_s, :type=>schema_column_type(t.to_s)}]]
       end
     end
     @db.extend(sm)
@@ -1563,6 +1563,7 @@ describe "Schema Parser" do
     @db.schema(:"character varying").first.last[:type].should == :string
     @db.schema(:varchar).first.last[:type].should == :string
     @db.schema(:"varchar(255)").first.last[:type].should == :string
+    @db.schema(:"varchar(255)").first.last[:max_length].should == 255
     @db.schema(:text).first.last[:type].should == :string
     @db.schema(:date).first.last[:type].should == :date
     @db.schema(:datetime).first.last[:type].should == :datetime

data/spec/extensions/auto_validations_spec.rb

@@ -2,13 +2,13 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::AutoValidations" do
   before do
-    db = Sequel.mock(:fetch=>{:v=>1})
+    db = Sequel.mock(:fetch=>proc{|sql| sql =~ /a{51}/ ? {:v=>0} : {:v=>1}})
     def db.schema_parse_table(*) true; end
     def db.schema(t, *)
       t = t.first_source if t.is_a?(Sequel::Dataset)
       return [] if t != :test
       [[:id, {:primary_key=>true, :type=>:integer, :allow_null=>false}],
-       [:name, {:primary_key=>false, :type=>:string, :allow_null=>false}],
+       [:name, {:primary_key=>false, :type=>:string, :allow_null=>false, :max_length=>50}],
        [:num, {:primary_key=>false, :type=>:integer, :allow_null=>true}],
        [:d, {:primary_key=>false, :type=>:date, :allow_null=>false}],
        [:nnd, {:primary_key=>false, :type=>:string, :allow_null=>false, :ruby_default=>'nnd'}]]
@@ -42,6 +42,10 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.set(:d=>Date.today, :num=>1)
     @m.valid?.should == false
     @m.errors.should == {[:name, :num]=>["is already taken"]}
+
+    @m.set(:name=>'a'*51)
+    @m.valid?.should == false
+    @m.errors.should == {:name=>["is longer than 50 characters"]}
   end
 
   it "should handle databases that don't support index parsing" do
@@ -86,6 +90,13 @@ describe "Sequel::Plugins::AutoValidations" do
 
     @c.skip_auto_validations(:unique)
     @m.valid?.should == true
+
+    @m.set(:name=>'a'*51)
+    @m.valid?.should == false
+    @m.errors.should == {:name=>["is longer than 50 characters"]}
+
+    @c.skip_auto_validations(:max_length)
+    @m.valid?.should == true
   end
 
   it "should allow skipping all auto validations" do
@@ -95,6 +106,8 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.valid?.should == true
     @m.set(:d=>'/', :num=>'a', :name=>'1')
     @m.valid?.should == true
+    @m.set(:name=>'a'*51)
+    @m.valid?.should == true
   end
 
   it "should work correctly in subclasses" do
@@ -110,6 +123,10 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.set(:d=>Date.today, :num=>1)
     @m.valid?.should == false
     @m.errors.should == {[:name, :num]=>["is already taken"]}
+
+    @m.set(:name=>'a'*51)
+    @m.valid?.should == false
+    @m.errors.should == {:name=>["is longer than 50 characters"]}
   end
 
   it "should work correctly in STI subclasses" do
@@ -128,6 +145,10 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.valid?.should == false
     @m.errors.should == {[:name, :num]=>["is already taken"]}
     @m.db.sqls.should == ["SELECT count(*) AS count FROM test WHERE ((name = '1') AND (num = 1)) LIMIT 1"]
+
+    @m.set(:name=>'a'*51)
+    @m.valid?.should == false
+    @m.errors.should == {:name=>["is longer than 50 characters"]}
   end
 
   it "should work correctly when changing the dataset" do

data/spec/extensions/nested_attributes_spec.rb

@@ -38,6 +38,7 @@ describe "NestedAttributes plugin" do
     @Artist.one_to_one :first_album, :class=>@Album, :key=>:artist_id
     @Album.many_to_one :artist, :class=>@Artist, :reciprocal=>:albums
     @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
+    @Tag.many_to_many :albums, :class=>@Album, :left_key=>:tag_id, :right_key=>:album_id, :join_table=>:at
     @Artist.nested_attributes :albums, :first_album, :destroy=>true, :remove=>true
     @Artist.nested_attributes :concerts, :destroy=>true, :remove=>true
     @Album.nested_attributes :artist, :tags, :destroy=>true, :remove=>true
@@ -117,9 +118,12 @@ describe "NestedAttributes plugin" do
   end
   
   it "should add new objects to the cached association array as soon as the *_attributes= method is called" do
-    a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:name=>'Al', :tags_attributes=>[{:name=>'T'}]}]})
+    a = @Artist.new({:name=>'Ar', :first_album_attributes=>{:name=>'B'}, :albums_attributes=>[{:name=>'Al', :tags_attributes=>[{:name=>'T'}]}]})
     a.albums.should == [@Album.new(:name=>'Al')]
+    a.albums.first.artist.should == a
     a.albums.first.tags.should == [@Tag.new(:name=>'T')]
+    a.first_album.should == @Album.new(:name=>'B')
+    a.first_album.artist.should == a
   end
   
   it "should support creating new objects with composite primary keys" do
@@ -608,4 +612,31 @@ describe "NestedAttributes plugin" do
     proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
     proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
   end
+
+  it "should allow per-call options via the set_nested_attributes method" do
+    @Tag.columns :id, :name, :number
+    @Album.nested_attributes :tags
+
+    al = @Album.load(:id=>10, :name=>'Al')
+    t = @Tag.load(:id=>30, :name=>'T', :number=>10)
+    al.associations[:tags] = [t]
+    al.set_nested_attributes(:tags, [{:id=>30, :name=>'T2'}, {:name=>'T3'}], :fields=>[:name])
+    @db.sqls.should == []
+    al.save
+    check_sql_array("UPDATE albums SET name = 'Al' WHERE (id = 10)",
+      "UPDATE tags SET name = 'T2' WHERE (id = 30)",
+      "INSERT INTO tags (name) VALUES ('T3')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
+    proc{al.set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::Error)
+    proc{al.set_nested_attributes(:tags, [{:name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::Error)
+  end
+
+  it "should have set_nested_attributes method raise error if called with a bad association" do
+    proc{@Album.load(:id=>10, :name=>'Al').set_nested_attributes(:tags2, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::Error)
+  end
+
+  it "should have set_nested_attributes method raise error if called with an association that doesn't support nested attributes" do
+    @Tag.columns :id, :name, :number
+    proc{@Album.load(:id=>10, :name=>'Al').set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::Error)
+  end
 end

data/spec/extensions/pg_static_cache_updater_spec.rb

@@ -77,4 +77,16 @@ describe "pg_static_cache_updater extension" do
     @db.fetch = {:v=>1234}
     proc{@db.listen_for_static_cache_updates(Class.new(Sequel::Model(@db[:table])))}.should raise_error(Sequel::Error)
   end
+
+  specify "#listen_for_static_cache_updates should handle a :before_thread_exit option" do
+    a = []
+    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345], :before_thread_exit=>proc{a << 1}).join
+    a.should == [1]
+  end
+
+  specify "#listen_for_static_cache_updates should call :before_thread_exit option even if listen raises an exception" do
+    a = []
+    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345], :after_listen=>proc{raise ArgumentError}, :before_thread_exit=>proc{a << 1}).join
+    a.should == [1]
+  end
 end

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -31,25 +31,25 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
 
   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"]
+    @db.sqls.should == ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE (albums.artist_id = 1) -- prepared"]
 
     @Artist.load(:id=>1).album
-    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1) LIMIT 1 -- prepared"]
+    @db.sqls.should == ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE (albums.artist_id = 1) LIMIT 1 -- prepared"]
 
     @Album.load(:id=>1, :artist_id=>2).artist
-    @db.sqls.should == ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- prepared"]
+    @db.sqls.should == ["SELECT id, id2 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) WHERE (albums_tags.album_id = 1) -- prepared"]
+    @db.sqls.should == ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) -- prepared"]
 
     @Album.load(:id=>1, :artist_id=>2).tag
-    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) LIMIT 1 -- prepared"]
+    @db.sqls.should == ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) LIMIT 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) WHERE (albums.artist_id = 1) -- prepared"]
+    @db.sqls.should == ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) WHERE (albums.artist_id = 1) -- prepared"]
 
     @Artist.load(:id=>1).tag
-    @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) WHERE (albums.artist_id = 1) LIMIT 1 -- prepared"]
+    @db.sqls.should == ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) WHERE (albums.artist_id = 1) LIMIT 1 -- prepared"]
   end
 
   specify "should run correct SQL for composite key associations" do
@@ -63,25 +63,25 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @Artist.one_through_many :tag, :clone=>:tags
 
     @Artist.load(:id=>1, :id2=>2).albums
-    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
+    @db.sqls.should == ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
 
     @Artist.load(:id=>1, :id2=>2).album
-    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) LIMIT 1 -- prepared"]
+    @db.sqls.should == ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) LIMIT 1 -- 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"]
+    @db.sqls.should == ["SELECT id, id2 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)) WHERE ((albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) -- prepared"]
+    @db.sqls.should == ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) -- prepared"]
 
     @Album.load(:id=>1, :artist_id=>2, :id2=>3).tag
-    @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)) WHERE ((albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) LIMIT 1 -- prepared"]
+    @db.sqls.should == ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) LIMIT 1 -- 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)) WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
+    @db.sqls.should == ["SELECT tags.id, tags.id2 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)) WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
 
     @Artist.load(:id=>1, :id2=>2).tag
-    @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)) WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) LIMIT 1 -- prepared"]
+    @db.sqls.should == ["SELECT tags.id, tags.id2 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)) WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) LIMIT 1 -- prepared"]
   end
 
   specify "should not run query if no objects can be associated" do
@@ -120,19 +120,19 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @Album.dataset = @Album.dataset.where(:a=>2)
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
     @Artist.load(:id=>1).albums
-    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 2) AND (albums.artist_id = 1)) -- prepared"]
+    @db.sqls.should == ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE ((a = 2) AND (albums.artist_id = 1)) -- prepared"]
   end
 
   specify "should use a prepared statement if the :conditions association option" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>2} 
     @Artist.load(:id=>1).albums
-    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 2) AND (albums.artist_id = 1)) -- prepared"]
+    @db.sqls.should == ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE ((a = 2) AND (albums.artist_id = 1)) -- prepared"]
   end
 
   specify "should not use a prepared statement if :conditions association option uses an identifier" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{Sequel.identifier('a')=>2}
     @Artist.load(:id=>1).albums
-    @db.sqls.should == ["SELECT * FROM albums WHERE ((a = 2) AND (albums.artist_id = 1)) -- prepared"]
+    @db.sqls.should == ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE ((a = 2) AND (albums.artist_id = 1)) -- prepared"]
   end
 
   specify "should run a regular query if :dataset option is used when defining the association" do