sequel 3.5.0 → 3.6.0

data/spec/integration/dataset_test.rb

@@ -25,37 +25,31 @@ describe "Simple Dataset operations" do
 
   cspecify "should insert with a primary key specified", :mssql do
     @ds.insert(:id=>100, :number=>20)
-    sqls_should_be(/INSERT INTO items \((number, id|id, number)\) VALUES \((100, 20|20, 100)\)/)
     @ds.count.should == 2
     @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
   end
 
   specify "should have insert return primary key value" do
     @ds.insert(:number=>20).should == 2
-    sqls_should_be('INSERT INTO items (number) VALUES (20)')
     @ds.filter(:id=>2).first[:number].should == 20
   end
 
   specify "should delete correctly" do
     @ds.filter(1=>1).delete.should == 1
-    sqls_should_be('DELETE FROM items WHERE (1 = 1)')
     @ds.count.should == 0
   end
 
   specify "should update correctly" do
     @ds.update(:number=>:number+1).should == 1
-    sqls_should_be('UPDATE items SET number = (number + 1)')
     @ds.all.should == [{:id=>1, :number=>11}]
   end
 
   specify "should fetch all results correctly" do
     @ds.all.should == [{:id=>1, :number=>10}]
-    sqls_should_be('SELECT * FROM items')
   end
 
   specify "should fetch a single row correctly" do
     @ds.first.should == {:id=>1, :number=>10}
-    sqls_should_be('SELECT * FROM items LIMIT 1')
   end
   
   specify "should fetch correctly with a limit" do
@@ -80,7 +74,6 @@ describe "Simple Dataset operations" do
 
   specify "should alias columns correctly" do
     @ds.select(:id___x, :number___n).first.should == {:x=>1, :n=>10}
-    sqls_should_be("SELECT id AS 'x', number AS 'n' FROM items LIMIT 1")
   end
 end
 
@@ -105,6 +98,20 @@ describe Sequel::Dataset do
     @d.count.should == 3
   end
 
+  specify "should handle aggregate methods on limited datasets correctly" do
+    @d << {:name => 'abc', :value => 6}
+    @d << {:name => 'bcd', :value => 12}
+    @d << {:name => 'def', :value => 18}
+    @d = @d.order(:name).limit(2)
+    @d.count.should == 2
+    @d.avg(:value).to_i.should == 9
+    @d.min(:value).to_i.should == 6
+    @d.reverse.min(:value).to_i.should == 12
+    @d.max(:value).to_i.should == 12
+    @d.sum(:value).to_i.should == 18
+    @d.interval(:value).to_i.should == 6
+  end
+
   specify "should return the correct records" do
     @d.to_a.should == []
     @d << {:name => 'abc', :value => 123}
@@ -247,7 +254,6 @@ describe "Simple Dataset operations in transactions" do
   cspecify "should insert correctly with a primary key specified inside a transaction", :mssql do
     INTEGRATION_DB.transaction do
       @ds.insert(:id=>100, :number=>20)
-      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
@@ -256,7 +262,6 @@ 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('BEGIN', /INSERT INTO items_insert_in_transaction \(number\) VALUES \(20\)/)
       @ds.count.should == 1
       @ds.order(:id).all.should == [{:id=>1, :number=>20}]
     end
@@ -495,4 +500,373 @@ describe "Sequel::Dataset#import and #multi_insert" do
     @ids.import([:i], @eds)
     @ids.all.should == [{:i=>10}, {:i=>20}]
   end
+  
+  it "should have import work with the :slice_size option" do
+    @ids.import([:i], [[10], [20], [30]], :slice_size=>1)
+    @ids.all.should == [{:i=>10}, {:i=>20}, {:i=>30}]
+    @ids.delete
+    @ids.import([:i], [[10], [20], [30]], :slice_size=>2)
+    @ids.all.should == [{:i=>10}, {:i=>20}, {:i=>30}]
+    @ids.delete
+    @ids.import([:i], [[10], [20], [30]], :slice_size=>3)
+    @ids.all.should == [{:i=>10}, {:i=>20}, {:i=>30}]
+  end
+end
+
+describe "Sequel::Dataset convenience methods" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){Integer :a; Integer :b}
+    @ds = @db[:a].order(:a)
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  it "#[]= should update matching rows" do
+    @ds.insert(20, 10)
+    @ds[:a=>20] = {:b=>30}
+    @ds.all.should == [{:a=>20, :b=>30}]
+  end
+  
+  it "#empty? should return whether the dataset returns no rows" do
+    @ds.empty?.should == true
+    @ds.insert(20, 10)
+    @ds.empty?.should == false
+  end
+  
+  it "#group_and_count should return a grouping by count" do
+    @ds.group_and_count(:a).all.should == []
+    @ds.insert(20, 10)
+    @ds.group_and_count(:a).all.each{|h| h[:count] = h[:count].to_i}.should == [{:a=>20, :count=>1}]
+    @ds.insert(20, 30)
+    @ds.group_and_count(:a).all.each{|h| h[:count] = h[:count].to_i}.should == [{:a=>20, :count=>2}]
+    @ds.insert(30, 30)
+    @ds.group_and_count(:a).all.each{|h| h[:count] = h[:count].to_i}.should == [{:a=>30, :count=>1}, {:a=>20, :count=>2}]
+  end
+  
+  it "#group_and_count should support column aliases" do
+    @ds.group_and_count(:a___c).all.should == []
+    @ds.insert(20, 10)
+    @ds.group_and_count(:a___c).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>20, :count=>1}]
+    @ds.insert(20, 30)
+    @ds.group_and_count(:a___c).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>20, :count=>2}]
+    @ds.insert(30, 30)
+    @ds.group_and_count(:a___c).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>30, :count=>1}, {:c=>20, :count=>2}]
+  end
+  
+  cspecify "#range should return the range between the maximum and minimum values", :sqlite do
+    @ds = @ds.unordered
+    @ds.insert(20, 10)
+    @ds.insert(30, 10)
+    @ds.range(:a).should == (20..30)
+    @ds.range(:b).should == (10..10)
+  end
+  
+  it "#interval should return the different between the maximum and minimum values" do
+    @ds = @ds.unordered
+    @ds.insert(20, 10)
+    @ds.insert(30, 10)
+    @ds.interval(:a).to_i.should == 10
+    @ds.interval(:b).to_i.should == 0
+  end
+end
+  
+describe "Sequel::Dataset main SQL methods" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){Integer :a; Integer :b}
+    @ds = @db[:a].order(:a)
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  it "#exists should return a usable exists clause" do
+    @ds.filter(@db[:a___c].filter(:c__a=>:a__b).exists).all.should == []
+    @ds.insert(20, 30)
+    @ds.insert(10, 20)
+    @ds.filter(@db[:a___c].filter(:c__a=>:a__b).exists).all.should == [{:a=>10, :b=>20}]
+  end
+  
+  it "#filter and #exclude should work with placeholder strings" do
+    @ds.insert(20, 30)
+    @ds.filter("a > ?", 15).all.should == [{:a=>20, :b=>30}]
+    @ds.exclude("b < ?", 15).all.should == [{:a=>20, :b=>30}]
+    @ds.filter("b < ?", 15).invert.all.should == [{:a=>20, :b=>30}]
+  end
+  
+  it "#and and #or should work with placeholder strings" do
+    @ds.insert(20, 30)
+    @ds.filter(:a=>20).and(:b=>30).all.should == [{:a=>20, :b=>30}]
+    @ds.filter(:a=>20).and(:b=>15).all.should == []
+    @ds.filter(:a=>20).or(:b=>15).all.should == [{:a=>20, :b=>30}]
+    @ds.filter(:a=>10).or(:b=>15).all.should == []
+  end
+  
+  it "#having should work correctly" do
+    @ds.unordered!
+    @ds.select{[b, max(a).as(c)]}.group(:b).having{max(a) > 30}.all.should == []
+    @ds.insert(20, 30)
+    @ds.select{[b, max(a).as(c)]}.group(:b).having{max(a) > 30}.all.should == []
+    @ds.insert(40, 20)
+    @ds.select{[b, max(a).as(c)]}.group(:b).having{max(a) > 30}.all.each{|h| h[:c] = h[:c].to_i}.should == [{:b=>20, :c=>40}]
+  end
+  
+  cspecify "#having should work without a previous group", :sqlite do
+    @ds.unordered!
+    @ds.select{max(a).as(c)}.having{max(a) > 30}.all.should == []
+    @ds.insert(20, 30)
+    @ds.select{max(a).as(c)}.having{max(a) > 30}.all.should == []
+    @ds.insert(40, 20)
+    @ds.select{max(a).as(c)}.having{max(a) > 30}.all.each{|h| h[:c] = h[:c].to_i}.should == [{:c=>40}]
+  end
+end
+
+describe "Sequel::Dataset DSL support" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){Integer :a; Integer :b}
+    @ds = @db[:a].order(:a)
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  it "should work with standard mathematical operators" do
+    @ds.insert(20, 10)
+    @ds.get{a + b}.to_i.should == 30
+    @ds.get{a - b}.to_i.should == 10
+    @ds.get{a * b}.to_i.should == 200
+    @ds.get{a / b}.to_i.should == 2
+  end
+  
+  cspecify "should work with standard bitwise mathematical operators", :mssql, :h2 do
+    @ds.insert(24, 2)
+    @ds.get{a.sql_number << b}.to_i.should == 96
+    @ds.get{a.sql_number >> b}.to_i.should == 6
+    @ds.delete
+    @ds.insert(3, 5)
+    @ds.get{a.sql_number | b}.to_i.should == 7
+    @ds.get{a.sql_number & b}.to_i.should == 1
+  end
+  
+  cspecify "should work with the bitwise compliment operator", :mysql, :h2 do
+    @ds.insert(3, 5)
+    @ds.get{~a.sql_number}.to_i.should == -4
+  end
+  
+  cspecify "should work with inequality operators", :mssql do
+    @ds.insert(20, 20)
+    ['0', 0, false].should include(@ds.get{a > b})
+    ['0', 0, false].should include(@ds.get{a < b})
+    ['1', 1, true].should include(@ds.get{a <= b})
+    ['1', 1, true].should include(@ds.get{a >= b})
+  end
+  
+  cspecify "should work with casting and string concatentation", :mssql do
+    @ds.insert(20, 20)
+    @ds.get{a.cast_string + b}.should == '2020'
+  end
+  
+  it "should work with ordering" do
+    @ds.insert(10, 20)
+    @ds.insert(20, 10)
+    @ds.order(:a, :b).all.should == [{:a=>10, :b=>20}, {:a=>20, :b=>10}]
+    @ds.order(:a.asc, :b.asc).all.should == [{:a=>10, :b=>20}, {:a=>20, :b=>10}]
+    @ds.order(:a.desc, :b.desc).all.should == [{:a=>20, :b=>10}, {:a=>10, :b=>20}]
+  end
+  
+  it "should work with qualifying" do
+    @ds.insert(10, 20)
+    @ds.get(:a__b).should == 20
+    @ds.get{a__b}.should == 20
+    @ds.get(:b.qualify(:a)).should == 20
+  end
+  
+  it "should work with aliasing" do
+    @ds.insert(10, 20)
+    @ds.get(:a__b___c).should == 20
+    @ds.get{a__b.as(c)}.should == 20
+    @ds.get(:b.qualify(:a).as(:c)).should == 20
+    @ds.get(:b.as(:c)).should == 20
+  end
+  
+  it "should work with selecting all columns of a table" do
+    @ds.insert(20, 10)
+    @ds.select(:a.*).all.should == [{:a=>20, :b=>10}]
+  end
+  
+  it "should work with ranges as hash values" do
+    @ds.insert(20, 10)
+    @ds.filter(:a=>(10..30)).all.should == [{:a=>20, :b=>10}]
+    @ds.filter(:a=>(25..30)).all.should == []
+    @ds.filter(:a=>(10..15)).all.should == []
+    @ds.exclude(:a=>(10..30)).all.should == []
+    @ds.exclude(:a=>(25..30)).all.should == [{:a=>20, :b=>10}]
+    @ds.exclude(:a=>(10..15)).all.should == [{:a=>20, :b=>10}]
+  end
+  
+  it "should work with nil as hash value" do
+    @ds.insert(20, nil)
+    @ds.filter(:a=>nil).all.should == []
+    @ds.filter(:b=>nil).all.should == [{:a=>20, :b=>nil}]
+    @ds.exclude(:b=>nil).all.should == []
+    @ds.exclude(:a=>nil).all.should == [{:a=>20, :b=>nil}]
+  end
+  
+  it "should work with ranges as hash values" do
+    @ds.insert(20, 10)
+    @ds.filter(:a=>(10..30)).all.should == [{:a=>20, :b=>10}]
+    @ds.filter(:a=>(25..30)).all.should == []
+    @ds.filter(:a=>(10..15)).all.should == []
+    @ds.exclude(:a=>(10..30)).all.should == []
+    @ds.exclude(:a=>(25..30)).all.should == [{:a=>20, :b=>10}]
+    @ds.exclude(:a=>(10..15)).all.should == [{:a=>20, :b=>10}]
+  end
+  
+  it "should work with CASE statements" do
+    @ds.insert(20, 10)
+    @ds.filter({{:a=>20}=>20}.case(0) > 0).all.should == [{:a=>20, :b=>10}]
+    @ds.filter({{:a=>15}=>20}.case(0) > 0).all.should == []
+    @ds.filter({20=>20}.case(0, :a) > 0).all.should == [{:a=>20, :b=>10}]
+    @ds.filter({15=>20}.case(0, :a) > 0).all.should == []
+  end
+  
+  it "should work multiple value arrays" do
+    @ds.insert(20, 10)
+    @ds.quote_identifiers = false
+    @ds.filter([:a, :b]=>[[20, 10]].sql_array).all.should == [{:a=>20, :b=>10}]
+    @ds.filter([:a, :b]=>[[10, 20]].sql_array).all.should == []
+    @ds.filter([:a, :b]=>[[20, 10], [1, 2]].sql_array).all.should == [{:a=>20, :b=>10}]
+    @ds.filter([:a, :b]=>[[10, 10], [20, 20]].sql_array).all.should == []
+    
+    @ds.exclude([:a, :b]=>[[20, 10]].sql_array).all.should == []
+    @ds.exclude([:a, :b]=>[[10, 20]].sql_array).all.should == [{:a=>20, :b=>10}]
+    @ds.exclude([:a, :b]=>[[20, 10], [1, 2]].sql_array).all.should == []
+    @ds.exclude([:a, :b]=>[[10, 10], [20, 20]].sql_array).all.should == [{:a=>20, :b=>10}]
+  end
+  
+  it "should work multiple conditions" do
+    @ds.insert(20, 10)
+    @ds.filter(:a=>20, :b=>10).all.should == [{:a=>20, :b=>10}]
+    @ds.filter([[:a, 20], [:b, 10]]).all.should == [{:a=>20, :b=>10}]
+    @ds.filter({:a=>20} & {:b=>10}).all.should == [{:a=>20, :b=>10}]
+    @ds.filter({:a=>20} | {:b=>5}).all.should == [{:a=>20, :b=>10}]
+    @ds.filter(~{:a=>10}).all.should == [{:a=>20, :b=>10}]
+  end
+end
+
+describe "SQL Extract Function" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){DateTime :a}
+    @ds = @db[:a].order(:a)
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  cspecify "should return the part of the datetime asked for", :sqlite, :mssql do
+    t = Time.now
+    @ds.insert(t)
+    @ds.get{a.extract(:year)}.should == t.year
+    @ds.get{a.extract(:month)}.should == t.month
+    @ds.get{a.extract(:day)}.should == t.day
+  end
+end
+
+describe "Dataset string methods" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){String :a; String :b}
+    @ds = @db[:a].order(:a)
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  it "#grep should return matching rows" do
+    @ds.insert('foo', 'bar')
+    @ds.grep(:a, 'foo').all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.grep(:b, 'foo').all.should == []
+    @ds.grep(:b, 'bar').all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.grep(:a, 'bar').all.should == []
+    @ds.grep([:a, :b], %w'foo bar').all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.grep([:a, :b], %w'boo far').all.should == []
+  end
+  
+  it "#like should return matching rows" do
+    @ds.insert('foo', 'bar')
+    @ds.filter(:a.like('foo')).all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.filter(:a.like('bar')).all.should == []
+    @ds.filter(:a.like('foo', 'bar')).all.should == [{:a=>'foo', :b=>'bar'}]
+  end
+  
+  it "#ilike should return matching rows, in a case insensitive manner" do
+    @ds.insert('foo', 'bar')
+    @ds.filter(:a.ilike('Foo')).all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.filter(:a.ilike('baR')).all.should == []
+    @ds.filter(:a.ilike('FOO', 'BAR')).all.should == [{:a=>'foo', :b=>'bar'}]
+  end
+  
+  it "should work with strings created with sql_string_join" do
+    @ds.insert('foo', 'bar')
+    @ds.get([:a, :b].sql_string_join).should == 'foobar'
+    @ds.get([:a, :b].sql_string_join(' ')).should == 'foo bar'
+  end
+end
+
+describe "Dataset identifier methods" do
+  before do
+    class ::String
+      def uprev
+        upcase.reverse
+      end
+    end
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){Integer :ab}
+    @ds = @db[:a].order(:ab)
+    @ds.insert(1)
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  it "#identifier_output_method should change how identifiers are output" do
+    @ds.identifier_output_method = :upcase
+    @ds.first.should == {:AB=>1}
+    @ds.identifier_output_method = :uprev
+    @ds.first.should == {:BA=>1}
+  end
+  
+  it "should work when not quoting identifiers" do
+    @ds.quote_identifiers = false
+    @ds.first.should == {:ab=>1}
+  end
+end
+
+describe "Dataset defaults and overrides" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){Integer :a}
+    @ds = @db[:a].order(:a)
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  it "#set_defaults should set defaults that can be overridden" do
+    @ds = @ds.set_defaults(:a=>10)
+    @ds.insert
+    @ds.insert(:a=>20)
+    @ds.all.should == [{:a=>10}, {:a=>20}]
+  end
+  
+  it "#set_overrides should set defaults that cannot be overridden" do
+    @ds = @ds.set_overrides(:a=>10)
+    @ds.insert
+    @ds.insert(:a=>20)
+    @ds.all.should == [{:a=>10}, {:a=>10}]
+  end
 end