sequel 4.12.0 → 4.13.0

data/spec/core/object_graph_spec.rb

@@ -58,6 +58,11 @@ describe Sequel::Dataset, "graphing" do
       ds.sql.should == 'SELECT points.id, points.x AS y, lines.id AS lines_id, lines.x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     end
 
+    it "should requalify currently selected columns in new graph if current dataset joins tables" do
+      ds = @ds1.cross_join(:lines).select(:points__id, :lines__id___lid, :lines__x, :lines__y).graph(@ds3, :x=>:id)
+      ds.sql.should == 'SELECT points.id, points.lid, points.x, points.y, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x FROM (SELECT points.id, lines.id AS lid, lines.x, lines.y FROM points CROSS JOIN lines) AS points LEFT OUTER JOIN graphs ON (graphs.x = points.id)'
+    end
+
     it "should raise error if currently selected expressions cannot be handled" do
       proc{@ds1.select(1).graph(@ds2, :x=>:id)}.should raise_error(Sequel::Error)
     end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -48,8 +48,8 @@ describe "class_table_inheritance plugin" do
     Object.send(:remove_const, :Employee)
   end
 
-  specify "should have simple_table = nil for subclasses" do
-    Employee.simple_table.should == "employees"
+  specify "should have simple_table = nil for all classes" do
+    Employee.simple_table.should == nil
     Manager.simple_table.should == nil
     Executive.simple_table.should == nil
     Staff.simple_table.should == nil
@@ -62,10 +62,10 @@ describe "class_table_inheritance plugin" do
     end
 
   specify "should use a joined dataset in subclasses" do
-    Employee.dataset.sql.should == 'SELECT * FROM employees'
-    Manager.dataset.sql.should == 'SELECT * FROM employees INNER JOIN managers USING (id)'
-    Executive.dataset.sql.should == 'SELECT * FROM employees INNER JOIN managers USING (id) INNER JOIN executives USING (id)'
-    Staff.dataset.sql.should == 'SELECT * FROM employees INNER JOIN staff USING (id)'
+    Employee.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind FROM employees'
+    Manager.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)'
+    Executive.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id)'
+    Staff.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)'
   end
   
   it "should return rows with the correct class based on the polymorphic_key value" do
@@ -80,7 +80,7 @@ describe "class_table_inheritance plugin" do
   
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance)
-    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
+    Employee.dataset._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
     Employee.all.collect{|x| x.class}.should == [Employee, Employee, Employee, Employee]
   end
   
@@ -147,22 +147,27 @@ describe "class_table_inheritance plugin" do
     o.valid?.should == true
   end
 
+  it "should set the type column field even when not validating" do
+    Employee.new.save(:validate=>false)
+    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Employee')"]
+  end
+
   it "should raise an error if attempting to create an anonymous subclass" do
     proc{Class.new(Manager)}.should raise_error(Sequel::Error)
   end
 
   it "should allow specifying a map of names to tables to override implicit mapping" do
-    Manager.dataset.sql.should == 'SELECT * FROM employees INNER JOIN managers USING (id)'
-    Staff.dataset.sql.should == 'SELECT * FROM employees INNER JOIN staff USING (id)'
+    Manager.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)'
+    Staff.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)'
   end
 
   it "should lazily load attributes for columns in subclass tables" do
     Manager.instance_dataset._fetch = Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2}
     m = Manager[1]
-    @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (id = 1) LIMIT 1']
+    @db.sqls.should == ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1']
     Executive.instance_dataset._fetch = Executive.dataset._fetch = {:num_managers=>3}
     m.num_managers.should == 3
-    @db.sqls.should == ['SELECT num_managers FROM employees INNER JOIN managers USING (id) INNER JOIN executives USING (id) WHERE (id = 1) LIMIT 1']
+    @db.sqls.should == ['SELECT executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id = 1) LIMIT 1']
     m.values.should == {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2, :num_managers=>3}
   end
 
@@ -224,12 +229,12 @@ describe "class_table_inheritance plugin" do
   it "should handle many_to_one relationships correctly" do
     Manager.dataset._fetch = {:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3}
     Staff.load(:manager_id=>3).manager.should == Executive.load(:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3)
-    @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (id = 3) LIMIT 1']
+    @db.sqls.should == ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 3) LIMIT 1']
   end
   
   it "should handle one_to_many relationships correctly" do
     Staff.dataset._fetch = {:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3}
     Executive.load(:id=>3).staff_members.should == [Staff.load(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)]
-    @db.sqls.should == ['SELECT * FROM employees INNER JOIN staff USING (id) WHERE (staff.manager_id = 3)']
+    @db.sqls.should == ['SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id) WHERE (staff.manager_id = 3)']
   end
 end

data/spec/extensions/column_select_spec.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::ColumnSelect" do
+  def set_cols(*cols)
+    @cols.replace(cols)
+  end
+
+  before do
+    cols = @cols = []
+    @db = Sequel.mock
+    @db.extend_datasets(Module.new{define_method(:columns){cols}})
+    set_cols :id, :a, :b, :c
+    @Album = Class.new(Sequel::Model(@db[:albums]))
+  end
+
+  it "should add a explicit column selections to existing dataset without explicit selection" do
+    @Album.plugin :column_select
+    @Album.dataset.sql.should == 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums'
+
+    @Album.dataset = :albs
+    @Album.dataset.sql.should == 'SELECT albs.id, albs.a, albs.b, albs.c FROM albs'
+
+    @Album.dataset = Sequel.identifier(:albs)
+    @Album.dataset.sql.should == 'SELECT albs.id, albs.a, albs.b, albs.c FROM albs'
+  end
+
+  it "should handle qualified tables" do
+    @Album.dataset = :s__albums
+    @Album.plugin :column_select
+    @Album.dataset.sql.should == 'SELECT s.albums.id, s.albums.a, s.albums.b, s.albums.c FROM s.albums'
+
+    @Album.dataset = Sequel.qualify(:s2, :albums)
+    @Album.dataset.sql.should == 'SELECT s2.albums.id, s2.albums.a, s2.albums.b, s2.albums.c FROM s2.albums'
+  end
+
+  it "should handle aliases" do
+    @Album.dataset = :albums___a
+    @Album.plugin :column_select
+    @Album.dataset.sql.should == 'SELECT a.id, a.a, a.b, a.c FROM albums AS a'
+
+    @Album.dataset = Sequel.as(:albums, :b)
+    @Album.dataset.sql.should == 'SELECT b.id, b.a, b.b, b.c FROM albums AS b'
+
+    @Album.dataset = :s__albums___a
+    @Album.dataset.sql.should == 'SELECT a.id, a.a, a.b, a.c FROM s.albums AS a'
+
+    @Album.dataset = @Album.db[:albums].from_self
+    @Album.dataset.sql.should == 'SELECT t1.id, t1.a, t1.b, t1.c FROM (SELECT * FROM albums) AS t1'
+
+    @Album.dataset = Sequel.as(@Album.db[:albums], :b)
+    @Album.dataset.sql.should == 'SELECT b.id, b.a, b.b, b.c FROM (SELECT * FROM albums) AS b'
+  end
+
+  it "should not add a explicit column selection selection on existing dataset with explicit selection" do
+    @Album.dataset = @Album.dataset.select(:name)
+    @Album.plugin :column_select
+    @Album.dataset.sql.should == 'SELECT name FROM albums'
+
+    @Album.dataset = @Album.dataset.select(:name, :artist)
+    @Album.dataset.sql.should == 'SELECT name, artist FROM albums'
+  end
+
+  it "should not add a explicit column selection on existing dataset with multiple tables" do
+    @Album.dataset = @Album.db.from(:a1, :a2)
+    @Album.plugin :column_select
+    @Album.dataset.sql.should == 'SELECT * FROM a1, a2'
+
+    @Album.dataset = @Album.db.from(:a1).cross_join(:a2)
+    @Album.dataset.sql.should == 'SELECT * FROM a1 CROSS JOIN a2'
+  end
+
+  it "should use explicit column selection for many_to_many associations" do
+    @Album.plugin :column_select
+    @Album.many_to_many :albums, :class=>@Album, :left_key=>:l, :right_key=>:r, :join_table=>:j
+    @Album.load(:id=>1).albums_dataset.sql.should == 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums INNER JOIN j ON (j.r = albums.id) WHERE (j.l = 1)'
+  end
+
+  it "should set not explicit column selection for many_to_many associations when overriding select" do
+    @Album.plugin :column_select
+    @Album.dataset = @Album.dataset.select(:a)
+    @Album.many_to_many :albums, :class=>@Album, :left_key=>:l, :right_key=>:r, :join_table=>:j
+    @Album.load(:id=>1).albums_dataset.sql.should == 'SELECT albums.* FROM albums INNER JOIN j ON (j.r = albums.id) WHERE (j.l = 1)'
+  end
+
+  it "should use the schema to get columns if available" do
+    def @db.supports_schema_parsing?() true end
+    def @db.schema(t, *)
+      [[:t, {}], [:d, {}]]
+    end
+    @Album.plugin :column_select
+    @Album.dataset.sql.should == 'SELECT albums.t, albums.d FROM albums'
+  end
+
+  it "should handle case where schema parsing does not produce results" do
+    def @db.supports_schema_parsing?() true end
+    def @db.schema_parse_table(t, *) [] end
+    @Album.plugin :column_select
+    @Album.dataset.sql.should == 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums'
+  end
+
+  it "works correctly when loaded on model without a dataset" do
+    c = Class.new(Sequel::Model)
+    c.plugin :column_select
+    sc = Class.new(c)
+    sc.dataset = @db[:a]
+    sc.dataset.sql.should == "SELECT a.id, a.a, a.b, a.c FROM a"
+  end
+end

data/spec/extensions/composition_spec.rb

@@ -27,6 +27,26 @@ describe "Composition plugin" do
     proc{@c.composition :date, :mapping=>[]}.should_not raise_error
   end
 
+  it "should handle validations of underlying columns" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    o = @c.new
+    def o.validate
+      [:year, :month, :day].each{|c| errors.add(c, "not present") unless send(c)}
+    end
+    o.valid?.should == false
+    o.date = Date.new(1, 2, 3)
+    o.valid?.should == true
+  end
+
+  it "should set column values even when not validating" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @c.load({}).set(:date=>Date.new(4, 8, 12)).save(:validate=>false)
+    sql = DB.sqls.last
+    sql.should include("year = 4")
+    sql.should include("month = 8")
+    sql.should include("day = 12")
+  end
+
   it ".compositions should return the reflection hash of compositions" do
     @c.compositions.should == {}
     @c.composition :date, :mapping=>[:year, :month, :day]

data/spec/extensions/dataset_source_alias_spec.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "dataset_source_alias extension" do
+  before do
+    @db = Sequel.mock
+    @db.extension(:dataset_source_alias)
+  end
+
+  it "should automatically alias datasets to their first source in #from" do
+    @db[@db[:a]].sql.should == 'SELECT * FROM (SELECT * FROM a) AS a'
+    @db[:a, @db[:b]].sql.should == 'SELECT * FROM a, (SELECT * FROM b) AS b'
+  end
+
+  it "should handle virtual row blocks in #from" do
+    @db.dataset.from{|_| @db[:a]}.sql.should == 'SELECT * FROM (SELECT * FROM a) AS a'
+    @db.dataset.from(:a){|_| @db[:b]}.sql.should == 'SELECT * FROM a, (SELECT * FROM b) AS b'
+  end
+
+  it "should automatically alias datasets to their first source in #join" do
+    @db[:a].cross_join(@db[:b]).sql.should == 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS b'
+  end
+
+  it "should handle :table_alias option when joining" do
+    @db[:a].cross_join(@db[:b], :table_alias=>:c).sql.should == 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS c'
+  end
+
+  it "should handle aliasing issues automatically" do
+    @db[:a, @db[:a]].sql.should == 'SELECT * FROM a, (SELECT * FROM a) AS a_0'
+    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.sql.should == 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1'
+    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.cross_join(@db[:a]).sql.should == 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1 CROSS JOIN (SELECT * FROM a) AS a_2'
+  end
+
+  it "should handle from_self" do
+    @db[:a].from_self.sql.should == 'SELECT * FROM (SELECT * FROM a) AS a'
+    @db[:a].from_self.from_self.sql.should == 'SELECT * FROM (SELECT * FROM (SELECT * FROM a) AS a) AS a'
+  end
+
+  it "should handle datasets without sources" do
+    @db[@db.select(1)].sql.should == 'SELECT * FROM (SELECT 1) AS t1'
+    @db[:t, @db.select(1)].sql.should == 'SELECT * FROM t, (SELECT 1) AS t1'
+    @db[:a].cross_join(@db.select(1)).sql.should == 'SELECT * FROM a CROSS JOIN (SELECT 1) AS t1'
+  end
+
+  it "should handle datasets selecting from functions" do
+    @db.dataset.from{|o| @db[o.f(:a)]}.sql.should == 'SELECT * FROM (SELECT * FROM f(a)) AS t1'
+  end
+
+  it "should handle datasets with literal SQL" do
+    @db.from(@db['SELECT c FROM d']).sql.should == 'SELECT * FROM (SELECT c FROM d) AS t1'
+  end
+end

data/spec/extensions/insert_returning_select_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::InsertReturningSelect" do
+  before do
+    @db = Sequel.mock(:fetch=>{:id=>1, :x=>2}, :autoid=>1)
+    @db.extend_datasets do
+      def supports_returning?(_) true end
+      def insert_select(*v) with_sql_first("#{insert_sql(*v)} RETURNING #{opts[:returning].map{|x| literal(x)}.join(', ')}") end
+    end
+    @Album = Class.new(Sequel::Model(@db[:albums].select(:id, :x)))
+    @Album.columns :id, :x
+    @db.sqls
+  end
+
+  it "should add a returning clause when inserting using selected columns" do
+    @Album.plugin :insert_returning_select
+    @Album.create(:x=>2).should == @Album.load(:id=>1, :x=>2)
+    @db.sqls.should == ['INSERT INTO albums (x) VALUES (2) RETURNING id, x']
+  end
+
+  it "should not add a returning clause if selection does not consist of just columns" do
+    @Album.dataset = @Album.dataset.select_append(Sequel.as(1, :b))
+    @Album.plugin :insert_returning_select
+    @db.sqls.clear
+    @Album.create(:x=>2).should == @Album.load(:id=>1, :x=>2)
+    @db.sqls.should == ['INSERT INTO albums (x) VALUES (2)', 'SELECT id, x, 1 AS b FROM albums WHERE (id = 1) LIMIT 1']
+  end
+
+  it "should not add a returning clause if database doesn't support it" do
+    @db.extend_datasets{def supports_returning?(_) false end}
+    @Album.plugin :insert_returning_select
+    @Album.create(:x=>2).should == @Album.load(:id=>1, :x=>2)
+    @db.sqls.should == ['INSERT INTO albums (x) VALUES (2)', 'SELECT id, x FROM albums WHERE (id = 1) LIMIT 1']
+  end
+
+  it "should work correctly with subclasses" do
+    c = Class.new(Sequel::Model)
+    c.plugin :insert_returning_select
+    b = Class.new(c)
+    b.columns :id, :x
+    b.dataset = @db[:albums].select(:id, :x)
+    @db.sqls.clear
+    b.create(:x=>2).should == b.load(:id=>1, :x=>2)
+    @db.sqls.should == ['INSERT INTO albums (x) VALUES (2) RETURNING id, x']
+  end
+end

data/spec/extensions/lazy_attributes_spec.rb

@@ -25,7 +25,7 @@ describe "Sequel::Plugins::LazyAttributes" do
           elsif sql =~ /id = (\d)/
             [$1]
           end.map do |x|
-            if sql =~ /SELECT name FROM/
+            if sql =~ /SELECT (la.)?name FROM/
               {:name=>x.to_s}
             else
               {:id=>x.to_i, :name=>x.to_s}
@@ -46,7 +46,6 @@ describe "Sequel::Plugins::LazyAttributes" do
     @c.set_dataset(@ds.select(:id, :blah))
     @c.dataset.sql.should == 'SELECT id, blah FROM la'
     @c.plugin :lazy_attributes, :blah
-    @c.dataset.opts[:select].should == [:id]
     @c.dataset.sql.should == 'SELECT id FROM la'
   end
   
@@ -54,13 +53,18 @@ describe "Sequel::Plugins::LazyAttributes" do
     @c.set_dataset(@ds.select(:id, :blah))
     @c.dataset.sql.should == 'SELECT id, blah FROM la'
     @c.lazy_attributes :blah
-    @c.dataset.opts[:select].should == [:id]
     @c.dataset.sql.should == 'SELECT id FROM la'
   end
 
+  it "should handle lazy attributes that are qualified in the selection" do
+    @c.set_dataset(@ds.select(:la__id, :la__blah))
+    @c.dataset.sql.should == 'SELECT la.id, la.blah FROM la'
+    @c.plugin :lazy_attributes, :blah
+    @c.dataset.sql.should == 'SELECT la.id FROM la'
+  end
+  
   it "should remove the attributes given from the SELECT columns of the model's dataset" do
-    @ds.opts[:select].should == [:id]
-    @ds.sql.should == 'SELECT id FROM la'
+    @ds.sql.should == 'SELECT la.id FROM la'
   end
 
   it "should still typecast correctly in lazy loaded column setters" do
@@ -80,16 +84,16 @@ describe "Sequel::Plugins::LazyAttributes" do
     m.values.should == {:id=>1}
     m.name.should == '1'
     m.values.should == {:id=>1, :name=>'1'}
-    @db.sqls.should == ['SELECT id FROM la LIMIT 1', 'SELECT name FROM la WHERE (id = 1) LIMIT 1']
+    @db.sqls.should == ['SELECT la.id FROM la LIMIT 1', 'SELECT la.name FROM la WHERE (id = 1) LIMIT 1']
   end
 
   it "should lazily load the attribute for a frozen model object" do
     m = @c.first
     m.freeze
     m.name.should == '1'
-    @db.sqls.should == ['SELECT id FROM la LIMIT 1', 'SELECT name FROM la WHERE (id = 1) LIMIT 1']
+    @db.sqls.should == ['SELECT la.id FROM la LIMIT 1', 'SELECT la.name FROM la WHERE (id = 1) LIMIT 1']
     m.name.should == '1'
-    @db.sqls.should == ['SELECT name FROM la WHERE (id = 1) LIMIT 1']
+    @db.sqls.should == ['SELECT la.name FROM la WHERE (id = 1) LIMIT 1']
   end
 
   it "should not lazily load the attribute for a single model object if the value already exists" do
@@ -98,7 +102,7 @@ describe "Sequel::Plugins::LazyAttributes" do
     m[:name] = '1'
     m.name.should == '1'
     m.values.should == {:id=>1, :name=>'1'}
-    @db.sqls.should == ['SELECT id FROM la LIMIT 1']
+    @db.sqls.should == ['SELECT la.id FROM la LIMIT 1']
   end
 
   it "should not lazily load the attribute for a single model object if it is a new record" do
@@ -114,16 +118,16 @@ describe "Sequel::Plugins::LazyAttributes" do
     ms.map{|m| m.name}.should == %w'1 2'
     ms.map{|m| m.values}.should == [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
     sqls = @db.sqls
-    ['SELECT id, name FROM la WHERE (id IN (1, 2))',
-     'SELECT id, name FROM la WHERE (id IN (2, 1))'].should include(sqls.pop)
-    sqls.should == ['SELECT id FROM la']
+    ['SELECT la.id, la.name FROM la WHERE (la.id IN (1, 2))',
+     'SELECT la.id, la.name FROM la WHERE (la.id IN (2, 1))'].should include(sqls.pop)
+    sqls.should == ['SELECT la.id FROM la']
   end
 
   it "should not eagerly load the attribute if model instance is frozen, and deal with other frozen instances if not frozen" do
     ms = @c.all
     ms.first.freeze
     ms.map{|m| m.name}.should == %w'1 2'
-    @db.sqls.should == ['SELECT id FROM la', 'SELECT name FROM la WHERE (id = 1) LIMIT 1', 'SELECT id, name FROM la WHERE (id IN (2))']
+    @db.sqls.should == ['SELECT la.id FROM la', 'SELECT la.name FROM la WHERE (id = 1) LIMIT 1', 'SELECT la.id, la.name FROM la WHERE (la.id IN (2))']
   end
 
   it "should add the accessors to a module included in the class, so they can be easily overridden" do
@@ -137,9 +141,9 @@ describe "Sequel::Plugins::LazyAttributes" do
     ms.map{|m| m.name}.should == %w'1-blah 2-blah'
     ms.map{|m| m.values}.should == [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
     sqls = @db.sqls
-    ['SELECT id, name FROM la WHERE (id IN (1, 2))',
-     'SELECT id, name FROM la WHERE (id IN (2, 1))'].should include(sqls.pop)
-    sqls.should == ['SELECT id FROM la']
+    ['SELECT la.id, la.name FROM la WHERE (la.id IN (1, 2))',
+     'SELECT la.id, la.name FROM la WHERE (la.id IN (2, 1))'].should include(sqls.pop)
+    sqls.should == ['SELECT la.id FROM la']
   end
 
   it "should work with the serialization plugin" do
@@ -152,15 +156,15 @@ describe "Sequel::Plugins::LazyAttributes" do
     ms.map{|m| m.deserialized_values}.should == [{:name=>3}, {:name=>6}]
     ms.map{|m| m.name}.should == [3,6]
     sqls = @db.sqls
-    ['SELECT id, name FROM la WHERE (id IN (1, 2))',
-     'SELECT id, name FROM la WHERE (id IN (2, 1))'].should include(sqls.pop)
-    sqls.should == ['SELECT id FROM la']
+    ['SELECT la.id, la.name FROM la WHERE (la.id IN (1, 2))',
+     'SELECT la.id, la.name FROM la WHERE (la.id IN (2, 1))'].should include(sqls.pop)
+    sqls.should == ['SELECT la.id FROM la']
     m = @ds.first
     m.values.should == {:id=>1}
     m.name.should == 3
     m.values.should == {:id=>1, :name=>"--- 3\n"}
     m.deserialized_values.should == {:name=>3}
     m.name.should == 3
-    @db.sqls.should == ["SELECT id FROM la LIMIT 1", "SELECT name FROM la WHERE (id = 1) LIMIT 1"]
+    @db.sqls.should == ["SELECT la.id FROM la LIMIT 1", "SELECT la.name FROM la WHERE (id = 1) LIMIT 1"]
   end
 end