sequel 3.0.0 → 3.1.0

data/spec/extensions/migration_spec.rb

@@ -135,7 +135,7 @@ context "Sequel::Migrator" do
     File.open('001_create_sessions.rb', 'w') {|f| f << MIGRATION_001}
     File.open('002_create_nodes.rb', 'w') {|f| f << MIGRATION_002}
     File.open('003_create_users.rb', 'w') {|f| f << MIGRATION_003}
-    File.open('005_create_attributes.rb', 'w') {|f| f << MIGRATION_005}
+    File.open('005_5_create_attributes.rb', 'w') {|f| f << MIGRATION_005}
     
     @db[:schema_info].version = nil
   end
@@ -149,7 +149,7 @@ context "Sequel::Migrator" do
     File.delete('001_create_sessions.rb')
     File.delete('002_create_nodes.rb')
     File.delete('003_create_users.rb')
-    File.delete('005_create_attributes.rb')
+    File.delete('005_5_create_attributes.rb')
   end
   
   specify "should return the list of files for a specified version range" do
@@ -159,8 +159,8 @@ context "Sequel::Migrator" do
     Sequel::Migrator.migration_files('.', 1..3).should == \
       ['./001_create_sessions.rb', './002_create_nodes.rb', './003_create_users.rb']
 
-    Sequel::Migrator.migration_files('.', 3..5).should == \
-      ['./003_create_users.rb', './005_create_attributes.rb']
+    Sequel::Migrator.migration_files('.', 3..6).should == \
+      ['./003_create_users.rb', './005_5_create_attributes.rb']
       
     Sequel::Migrator.migration_files('.', 7..8).should == []
   end

data/spec/extensions/schema_dumper_spec.rb

@@ -78,11 +78,6 @@ describe "Sequel::Database dump methods" do
       when :t3
         [[:c1, {:db_type=>'date', :default=>"'now()'", :allow_null=>true}],
          [:c2, {:db_type=>'datetime', :allow_null=>false}]]
-      when :t4
-        [[:c1, {:db_type=>'boolean', :default=>"false", :allow_null=>true}],
-         [:c2, {:db_type=>'boolean', :default=>"true", :allow_null=>true}],
-         [:c3, {:db_type=>'varchar', :default=>"'blah'", :allow_null=>true}],
-         [:c4, {:db_type=>'integer', :default=>"35", :allow_null=>true}]]
       when :t5
         [[:c1, {:db_type=>'blahblah', :allow_null=>true}]]
       end
@@ -102,7 +97,7 @@ describe "Sequel::Database dump methods" do
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
-    @d.dump_table_schema(:t1).should == "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1], :unique=>true\nend"
+    @d.dump_table_schema(:t1).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1], :unique=>true\nend"
   end
 
   it "should support dumping the whole database as a migration" do
@@ -129,6 +124,31 @@ end
 END_MIG
   end
 
+  it "should sort table names when dumping a migration" do
+    @d.meta_def(:tables){[:t2, :t1]}
+    @d.dump_schema_migration.should == <<-END_MIG
+Class.new(Sequel::Migration) do
+  def up
+    create_table(:t1) do
+      primary_key :c1
+      String :c2, :size=>20
+    end
+    
+    create_table(:t2) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+    end
+  end
+  
+  def down
+    drop_table(:t1, :t2)
+  end
+end
+END_MIG
+  end
+
   it "should honor the :same_db option to not convert types" do
     @d.dump_table_schema(:t1, :same_db=>true).should == "create_table(:t1) do\n  primary_key :c1\n  column :c2, \"varchar(20)\"\nend"
     @d.dump_schema_migration(:same_db=>true).should == <<-END_MIG
@@ -192,24 +212,105 @@ END_MIG
     @d.dump_indexes_migration.should == <<-END_MIG
 Class.new(Sequel::Migration) do
   def up
-    add_index :t1, [:c1], :name=>:i1
-    add_index :t1, [:c2, :c1], :unique=>true
+    add_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+    add_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
   end
   
   def down
-    drop_index :t1, [:c1], :name=>:i1
-    drop_index :t1, [:c2, :c1], :unique=>true
+    drop_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+    drop_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
   end
 end
 END_MIG
   end
 
   it "should handle not null values and defaults" do
-    @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  Date :c1, :default=>\"'now()'\".lit\n  DateTime :c2, :null=>false\nend"
+    @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  Date :c1\n  DateTime :c2, :null=>false\nend"
   end
-
+  
+  it "should handle converting many default formats" do
+    m = @d.method(:column_schema_to_ruby_default)
+    m.call("adf", :string, :same_db=>true).inspect.should == '"adf".lit'
+    p = lambda{|d,t| m.call(d,t,{})}
+    p[nil, :integer].should == nil
+    p['1', :integer].should == 1
+    p['-1', :integer].should == -1
+    p['1.0', :float].should == 1.0
+    p['-1.0', :float].should == -1.0
+    p['1.0', :decimal].should == BigDecimal.new('1.0')
+    p['-1.0', :decimal].should == BigDecimal.new('-1.0')
+    p['1', :boolean].should == true
+    p['0', :boolean].should == false
+    p['true', :boolean].should == true
+    p['false', :boolean].should == false
+    p["'t'", :boolean].should == true
+    p["'f'", :boolean].should == false
+    p["'a'", :string].should == 'a'
+    p["'a'", :blob].should == 'a'.to_sequel_blob
+    p["'a'", :blob].should be_a_kind_of(Sequel::SQL::Blob)
+    p["''", :string].should == ''
+    p["'\\a''b'", :string].should == "\\a'b"
+    p["'NULL'", :string].should == "NULL"
+    p["'2009-10-29'", :date].should == Date.new(2009,10,29)
+    p["CURRENT_TIMESTAMP", :date].should == nil
+    p["today()", :date].should == nil
+    p["'2009-10-29T10:20:30-07:00'", :datetime].should == DateTime.parse('2009-10-29T10:20:30-07:00')
+    p["'2009-10-29 10:20:30'", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
+    p["'10:20:30'", :time].should == Time.parse('10:20:30')
+    p["NaN", :float].should == nil
+  end
+  
   it "should handle converting common defaults" do
-    @d.dump_table_schema(:t4).should == "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  TrueClass :c2, :default=>true\n  String :c3, :default=>\"'blah'\".lit\n  Integer :c4, :default=>35\nend"
+    @d.meta_def(:schema) do |t, *os|
+      [[:c1, {:db_type=>'boolean', :default=>"false", :type=>:boolean, :allow_null=>true}],
+       [:c2, {:db_type=>'varchar', :default=>"'blah'", :type=>:string, :allow_null=>true}],
+       [:c3, {:db_type=>'integer', :default=>"-1", :type=>:integer, :allow_null=>true}],
+       [:c4, {:db_type=>'float', :default=>"1.0", :type=>:float, :allow_null=>true}],
+       [:c5, {:db_type=>'decimal', :default=>"100.50", :type=>:decimal, :allow_null=>true}],
+       [:c6, {:db_type=>'blob', :default=>"'blah'", :type=>:blob, :allow_null=>true}],
+       [:c7, {:db_type=>'date', :default=>"'2008-10-29'", :type=>:date, :allow_null=>true}],
+       [:c8, {:db_type=>'datetime', :default=>"'2008-10-29 10:20:30'", :type=>:datetime, :allow_null=>true}],
+       [:c9, {:db_type=>'time', :default=>"'10:20:30'", :type=>:time, :allow_null=>true}],
+       [:c10, {:db_type=>'interval', :default=>"'6 weeks'", :type=>:interval, :allow_null=>true}]]
+    end
+    @d.dump_table_schema(:t4).gsub(/[+-]\d\d:\d\d"\)/, '")').should == "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal.new(\"0.1005E3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.parse(\"2008-10-29\")\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30\")\n  Time :c9, :default=>Time.parse(\"10:20:30\"), :only_time=>true\n  String :c10\nend"
+    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d:\d\d"\)/, '")').should == "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005E3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.parse(\"2008-10-29\")\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30\")\n  column :c9, \"time\", :default=>Time.parse(\"10:20:30\")\n  column :c10, \"interval\", :default=>\"'6 weeks'\".lit\nend"
+  end
+  
+  it "should handle converting PostgreSQL specific default formats" do
+    m = @d.method(:column_schema_to_ruby_default)
+    @d.meta_def(:database_type){:postgres}
+    p = lambda{|d,t| m.call(d,t,{})}
+    p["''::text", :string].should == ""
+    p["'\\a''b'::character varying", :string].should == "\\a'b"
+    p["'a'::bpchar", :string].should == "a"
+    p["(-1)", :integer].should == -1
+    p["(-1.0)", :float].should == -1.0
+    p['(-1.0)', :decimal].should == BigDecimal.new('-1.0')
+    p["'a'::bytea", :blob].should == 'a'.to_sequel_blob
+    p["'a'::bytea", :blob].should be_a_kind_of(Sequel::SQL::Blob)
+    p["'2009-10-29'::date", :date].should == Date.new(2009,10,29)
+    p["'2009-10-29 10:20:30.241343'::timestamp without time zone", :datetime].should == DateTime.parse('2009-10-29 10:20:30.241343')
+    p["'10:20:30'::time without time zone", :time].should == Time.parse('10:20:30')
+  end
+  
+  it "should handle converting MySQL specific default formats" do
+    m = @d.method(:column_schema_to_ruby_default)
+    @d.meta_def(:database_type){:mysql}
+    p = lambda{|d,t| m.call(d,t,{})}
+    s = lambda{|d,t| m.call(d,t,{:same_db=>true})}
+    p["\\a'b", :string].should == "\\a'b"
+    p["a", :string].should == "a"
+    p["NULL", :string].should == "NULL"
+    p["-1", :float].should == -1.0
+    p['-1', :decimal].should == BigDecimal.new('-1.0')
+    p["2009-10-29", :date].should == Date.new(2009,10,29)
+    p["2009-10-29 10:20:30", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
+    p["10:20:30", :time].should == Time.parse('10:20:30')
+    p["CURRENT_DATE", :date].should == nil
+    p["CURRENT_TIMESTAMP", :datetime].should == nil
+    s["CURRENT_DATE", :date].inspect.should == "\"CURRENT_DATE\".lit"
+    s["CURRENT_TIMESTAMP", :datetime].inspect.should == "\"CURRENT_TIMESTAMP\".lit"
   end
 
   it "should convert unknown database types to strings" do

data/spec/extensions/schema_spec.rb

@@ -95,8 +95,7 @@ describe Sequel::Model, "drop_table" do
 end
 
 describe Sequel::Model, "create_table!" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
     @model = Class.new(Sequel::Model(:items))
   end
@@ -104,8 +103,25 @@ describe Sequel::Model, "create_table!" do
   it "should drop table if it exists and then create the table" do
     @model.should_receive(:drop_table).and_return(true)
     @model.should_receive(:create_table).and_return(true)
-
     @model.create_table!
   end
+end
 
+describe Sequel::Model, "create_table?" do
+  before do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+  
+  it "should not create the table if it already exists" do
+    @model.should_receive(:table_exists?).and_return(true)
+    @model.should_not_receive(:create_table)
+    @model.create_table?.should == nil
+  end
+
+  it "should create the table if it doesn't exist" do
+    @model.should_receive(:table_exists?).and_return(false)
+    @model.should_receive(:create_table).and_return(3)
+    @model.create_table?.should == 3
+  end
 end

data/spec/extensions/serialization_spec.rb

@@ -14,6 +14,16 @@ describe "Serialization plugin" do
     end
     MODEL_DB.reset
   end
+  
+  it "should allow setting additional serializable attributes via plugin :serialization call" do
+    @c.plugin :serialization, :yaml, :abc
+    @c.create(:abc => 1, :def=> 2)
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n', 2|2, '--- 1\n')\)/
+
+    @c.plugin :serialization, :marshal, :def
+    @c.create(:abc => 1, :def=> 1)
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n')\)/
+  end
 
   it "should allow serializing attributes to yaml" do
     @c.plugin :serialization, :yaml, :abc
@@ -26,6 +36,16 @@ describe "Serialization plugin" do
     ]
   end
 
+  it "serialization_format should be the serialization format used" do
+    @c.plugin :serialization, :yaml, :abc
+    @c.serialization_format.should == :yaml
+  end
+
+  it "serialized_columns should be the columns serialized" do
+    @c.plugin :serialization, :yaml, :abc
+    @c.serialized_columns.should == [:abc]
+  end
+
   it "should allow serializing attributes to marshal" do
     @c.plugin :serialization, :marshal, :abc
     @c.create(:abc => 1)
@@ -115,4 +135,12 @@ describe "Serialization plugin" do
     o.refresh
     o.deserialized_values.length.should == 0
   end
+  
+  it "should raise an error if calling internal serialization methods with bad columns" do
+    @c.set_primary_key :id
+    @c.plugin :serialization
+    o = @c.load(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
+    lambda{o.send(:serialize_value, :abc, 1)}.should raise_error(Sequel::Error)
+    lambda{o.send(:deserialize_value, :abc, "--- hello\n")}.should raise_error(Sequel::Error)
+  end
 end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -13,13 +13,37 @@ describe Sequel::Model, "#sti_key" do
     end 
     @ds = StiTest.dataset
     MODEL_DB.reset
-  end 
+  end
+  after do
+    Object.send(:remove_const, :StiTestSub1)
+    Object.send(:remove_const, :StiTestSub2)
+    Object.send(:remove_const, :StiTest)
+  end
 
   specify "should have simple_table = nil" do
     StiTest.simple_table.should == nil
     StiTestSub1.simple_table.should == nil
   end
   
+  it "should allow changing the inheritance column via a plugin :single_table_inheritance call" do
+    StiTest.plugin :single_table_inheritance, :blah
+    Object.send(:remove_const, :StiTestSub1)
+    Object.send(:remove_const, :StiTestSub2)
+    class ::StiTestSub1 < StiTest
+    end 
+    class ::StiTestSub2 < StiTest
+    end 
+    def @ds.fetch_rows(sql)
+      yield({:blah=>'StiTest'})
+      yield({:blah=>'StiTestSub1'})
+      yield({:blah=>'StiTestSub2'})
+    end 
+    StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
+    StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
+    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (blah = 'StiTestSub1')"
+    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (blah = 'StiTestSub2')"
+  end 
+  
   it "should return rows with the correct class based on the polymorphic_key value" do
     def @ds.fetch_rows(sql)
       yield({:kind=>'StiTest'})

data/spec/extensions/spec_helper.rb

@@ -8,13 +8,8 @@ unless Sequel.const_defined?('Model')
   require 'sequel/model'
 end
 
-Sequel.virtual_row_instance_eval = true
-
-extensions = %w'string_date_time inflector pagination query pretty_table blank migration schema_dumper'
-plugins = {:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}
-
-extensions.each{|e| require "sequel/extensions/#{e}"}
-plugins.each{|p, opts| Sequel::Model.plugin(p, *opts)}
+Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper')
+{:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}.each{|p, opts| Sequel::Model.plugin(p, *opts)}
 
 class MockDataset < Sequel::Dataset
   def insert(*args)

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel::Plugins::TacticalEagerLoading" do
+  before do
+    class ::TaticalEagerLoadingModel < Sequel::Model
+      plugin :tactical_eager_loading
+      columns :id, :parent_id
+      many_to_one :parent, :class=>self
+      one_to_many :children, :class=>self, :key=>:parent_id
+      ds = dataset
+      def ds.fetch_rows(sql)
+        execute(sql)
+        where = @opts[:where]
+        if !where
+          yield(:id=>1, :parent_id=>101)
+          yield(:id=>2, :parent_id=>102)
+          yield(:id=>101, :parent_id=>nil)
+          yield(:id=>102, :parent_id=>nil)
+        elsif where.args.first.column == :id
+          Array(where.args.last).each do |x|
+            yield(:id=>x, :parent_id=>nil)
+          end
+        elsif where.args.first.column == :parent_id
+          Array(where.args.last).each do |x|
+            yield(:id=>x-100, :parent_id=>x) if x > 100
+          end
+        end
+      end
+    end
+    @c = ::TaticalEagerLoadingModel
+    @ds = TaticalEagerLoadingModel.dataset
+    MODEL_DB.reset
+  end
+  after do
+    Object.send(:remove_const, :TaticalEagerLoadingModel)
+  end
+
+  it "Dataset#all should set the retrieved_by and reteived_with attributes" do
+    ts = @c.all
+    ts.map{|x| [x.retrieved_by, x.retrieved_with]}.should == [[@ds,ts], [@ds,ts], [@ds,ts], [@ds,ts]]
+  end
+
+  it "Dataset#all shouldn't raise an error if a Sequel::Model instance is not returned" do
+    proc{@c.naked.all}.should_not raise_error
+  end
+
+  it "association getter methods should eagerly load the association if the association isn't cached" do
+    MODEL_DB.sqls.length.should == 0
+    ts = @c.all
+    MODEL_DB.sqls.length.should == 1
+    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
+    MODEL_DB.sqls.length.should == 2
+    ts.map{|x| x.children}.should == [[], [], [ts[0]], [ts[1]]]
+    MODEL_DB.sqls.length.should == 3
+  end
+
+  it "association getter methods should not eagerly load the association if the association is cached" do
+    MODEL_DB.sqls.length.should == 0
+    ts = @c.all
+    MODEL_DB.sqls.length.should == 1
+    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
+    @ds.should_not_receive(:eager_load)
+    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
+  end
+end

data/spec/extensions/validation_class_methods_spec.rb

@@ -116,7 +116,8 @@ end
 
 describe Sequel::Model do
   before do
-    @c = Class.new(Sequel::Model) do
+    @c = Class.new(Sequel::Model)
+    @c.class_eval do
       columns :score
       validates_each :score do |o, a, v|
         o.errors[a] << 'too low' if v < 87
@@ -551,12 +552,14 @@ end
 
 context "Superclass validations" do
   before do
-    @c1 = Class.new(Sequel::Model) do
+    @c1 = Class.new(Sequel::Model)
+    @c1.class_eval do
       columns :value
       validates_length_of :value, :minimum => 5
     end
     
-    @c2 = Class.new(@c1) do
+    @c2 = Class.new(@c1)
+    @c2.class_eval do
       columns :value
       validates_format_of :value, :with => /^[a-z]+$/
     end
@@ -601,7 +604,8 @@ end
 
 context ".validates with block" do
   specify "should support calling .each" do
-    @c = Class.new(Sequel::Model) do
+    @c = Class.new(Sequel::Model)
+    @c.class_eval do
       columns :vvv
       validates do
         each :vvv do |o, a, v|
@@ -938,7 +942,8 @@ end
 
 describe "Model#save" do
   before do
-    @c = Class.new(Sequel::Model(:people)) do
+    @c = Class.new(Sequel::Model(:people))
+    @c.class_eval do
       columns :id
 
       validates_each :id do |o, a, v|

data/spec/integration/dataset_test.rb

@@ -120,7 +120,9 @@ describe Sequel::Dataset do
     proc {@d.literal(true)}.should_not raise_error
     proc {@d.literal(false)}.should_not raise_error
   end
+end
 
+describe Sequel::Database do
   specify "should correctly escape strings" do
     INTEGRATION_DB.get("\\dingo".as(:a)) == "\\dingo"
   end
@@ -132,6 +134,14 @@ describe Sequel::Dataset do
   specify "should properly escape binary data" do
     INTEGRATION_DB.get("\1\2\3".to_sequel_blob.as(:a)) == "\1\2\3"
   end
+
+  specify "should have a working table_exists?" do
+    t = :basdfdsafsaddsaf
+    INTEGRATION_DB.drop_table(t) rescue nil
+    INTEGRATION_DB.table_exists?(t).should == false
+    INTEGRATION_DB.create_table(t){Integer :a}
+    INTEGRATION_DB.table_exists?(t).should == true
+  end
 end
 
 context "An SQLite dataset" do
@@ -208,7 +218,7 @@ describe "Simple Dataset operations in transactions" do
   specify "should insert correctly with a primary key specified inside a transaction" do
     INTEGRATION_DB.transaction do
       @ds.insert(:id=>100, :number=>20)
-      sqls_should_be('Transaction.begin', /INSERT INTO items_insert_in_transaction \((number, id|id, number)\) VALUES \((100, 20|20, 100)\)/)
+      sqls_should_be('BEGIN', /INSERT INTO items_insert_in_transaction \((number, id|id, number)\) VALUES \((100, 20|20, 100)\)/)
       @ds.count.should == 1
       @ds.order(:id).all.should == [{:id=>100, :number=>20}]
     end
@@ -217,7 +227,7 @@ describe "Simple Dataset operations in transactions" do
   specify "should have insert return primary key value inside a transaction" do
     INTEGRATION_DB.transaction do
       @ds.insert(:number=>20).should == 1
-      sqls_should_be('Transaction.begin', /INSERT INTO items_insert_in_transaction \(number\) VALUES \(20\)/)
+      sqls_should_be('BEGIN', /INSERT INTO items_insert_in_transaction \(number\) VALUES \(20\)/)
       @ds.count.should == 1
       @ds.order(:id).all.should == [{:id=>1, :number=>20}]
     end
@@ -228,16 +238,12 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
   before do
     INTEGRATION_DB.create_table!(:i1){integer :number}
     INTEGRATION_DB.create_table!(:i2){integer :number}
-    INTEGRATION_DB.create_table!(:i3){integer :number}
     @ds1 = INTEGRATION_DB[:i1]
     @ds1.insert(:number=>10)
     @ds1.insert(:number=>20)
     @ds2 = INTEGRATION_DB[:i2]
     @ds2.insert(:number=>10)
     @ds2.insert(:number=>30)
-    @ds3 = INTEGRATION_DB[:i3]
-    @ds3.insert(:number=>10)
-    @ds3.insert(:number=>40)
     clear_sqls
   end
   
@@ -249,7 +255,34 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
     end
   end
   
+  specify "should give the correct results for UNION, EXCEPT, and INTERSECT when used with ordering and limits" do
+    @ds1.insert(:number=>8)
+    @ds2.insert(:number=>9)
+    @ds1.insert(:number=>38)
+    @ds2.insert(:number=>39)
+
+    @ds1.order(:number.desc).union(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'8 9 10 20 30 38 39'
+    @ds1.union(@ds2.order(:number.desc)).order(:number).map{|x| x[:number].to_s}.should == %w'8 9 10 20 30 38 39'
+
+    @ds1.order(:number.desc).limit(1).union(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'9 10 30 38 39'
+    @ds2.order(:number.desc).limit(1).union(@ds1).order(:number).map{|x| x[:number].to_s}.should == %w'8 10 20 38 39'
+
+    @ds1.union(@ds2.order(:number).limit(1)).order(:number).map{|x| x[:number].to_s}.should == %w'8 9 10 20 38'
+    @ds2.union(@ds1.order(:number).limit(1)).order(:number).map{|x| x[:number].to_s}.should == %w'8 9 10 30 39'
+
+    @ds1.union(@ds2).limit(2).order(:number).map{|x| x[:number].to_s}.should == %w'8 9'
+    @ds2.union(@ds1).order(:number.desc).limit(2).map{|x| x[:number].to_s}.should == %w'39 38'
+
+    @ds1.order(:number.desc).limit(2).union(@ds2.order(:number.desc).limit(2)).order(:number).limit(3).map{|x| x[:number].to_s}.should == %w'20 30 38'
+    @ds2.order(:number).limit(2).union(@ds1.order(:number).limit(2)).order(:number.desc).limit(3).map{|x| x[:number].to_s}.should == %w'10 9 8'
+  end
+
   specify "should give the correct results for compound UNION, EXCEPT, and INTERSECT" do
+    INTEGRATION_DB.create_table!(:i3){integer :number}
+    @ds3 = INTEGRATION_DB[:i3]
+    @ds3.insert(:number=>10)
+    @ds3.insert(:number=>40)
+
     @ds1.union(@ds2).union(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
     @ds1.union(@ds2.union(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
     unless defined?(Sequel::Dataset::UnsupportedIntersectExcept) and @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)