sequel 3.5.0 → 3.6.0

data/spec/adapters/mysql_spec.rb

@@ -787,6 +787,25 @@ context "MySQL::Dataset#replace" do
     MYSQL_DB.drop_table(:items)
   end
   
+  specify "should use default values if they exist" do
+    MYSQL_DB.alter_table(:items){set_column_default :id, 1; set_column_default :value, 2}
+    @d.replace
+    @d.all.should == [{:id=>1, :value=>2}]
+    @d.replace([])
+    @d.all.should == [{:id=>1, :value=>2}]
+    @d.replace({})
+    @d.all.should == [{:id=>1, :value=>2}]
+  end
+  
+  specify "should use support arrays, datasets, and multiple values" do
+    @d.replace([1, 2])
+    @d.all.should == [{:id=>1, :value=>2}]
+    @d.replace(1, 2)
+    @d.all.should == [{:id=>1, :value=>2}]
+    @d.replace(@d)
+    @d.all.should == [{:id=>1, :value=>2}]
+  end
+  
   specify "should create a record if the condition is not met" do
     @d.replace(:id => 111, :value => 333)
     @d.all.should == [{:id => 111, :value => 333}]

data/spec/adapters/postgres_spec.rb

@@ -129,6 +129,24 @@ context "A PostgreSQL dataset" do
     @d.filter(:name => /bc/).count.should == 2
     @d.filter(:name => /^bc/).count.should == 1
   end
+  
+  specify "should support for_share and for_update" do
+    @d.for_share.all.should == []
+    @d.for_update.all.should == []
+  end
+  
+  specify "#lock should lock tables and yield if a block is given" do
+    @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}
+  end
+  
+  specify "#lock should lock table if inside a transaction" do
+    POSTGRES_DB.transaction{@d.lock('EXCLUSIVE'); @d.insert(:name=>'a')}
+  end
+  
+  specify "#lock should return nil" do
+    @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}.should == nil
+    POSTGRES_DB.transaction{@d.lock('EXCLUSIVE').should == nil; @d.insert(:name=>'a')}
+  end
 end
 
 context "A PostgreSQL dataset with a timestamp field" do
@@ -189,6 +207,11 @@ context "A PostgreSQL database" do
     
     @db[:test2].first[:xyz].should == 57
   end
+  
+  specify "#locks should be a dataset returning database locks " do
+    @db.locks.should be_a_kind_of(Sequel::Dataset)
+    @db.locks.all.should be_a_kind_of(Array)
+  end
 end  
 
 context "A PostgreSQL database" do
@@ -217,7 +240,6 @@ context "A PostgreSQL database" do
     @db.reset_primary_key_sequence(:posts).should == nil
   end
   
-  
   specify "should support opclass specification" do
     @db.create_table(:posts){text :title; text :body; integer :user_id; index(:user_id, :opclass => :int4_ops, :type => :btree)}
     @db.sqls.should == [
@@ -287,6 +309,11 @@ context "A PostgreSQL database" do
       "CREATE INDEX posts_title_index ON posts (title) WHERE (title = '5')"
     ]
   end
+  
+  specify "should support renaming tables" do
+    @db.create_table!(:posts1){primary_key :a}
+    @db.rename_table(:posts1, :posts)
+  end
 end
 
 context "Postgres::Dataset#import" do
@@ -393,7 +420,7 @@ context "Postgres::Dataset#insert" do
     @ds.disable_insert_returning.insert_select(:value=>10).should == nil
   end
 
-  specify "should have insert_select insert the record and return the inserted record if server_version < 80200" do
+  specify "should have insert_select insert the record and return the inserted record if server_version >= 80200" do
     @ds.meta_def(:server_version){80201}
     h = @ds.insert_select(:value=>10)
     h[:value].should == 10
@@ -635,3 +662,39 @@ context "Postgres::Database functions, languages, and triggers" do
     @d.drop_trigger(:test, :identity, :if_exists=>true, :cascade=>true)
   end
 end
+
+if POSTGRES_DB.class.adapter_scheme == :postgres
+context "Postgres::Dataset #use_cursor" do
+  before(:all) do
+    @db = POSTGRES_DB
+    @db.create_table!(:test_cursor){Integer :x}
+    @db.sqls.clear
+    @ds = @db[:test_cursor]
+    @db.transaction{1001.times{|i| @ds.insert(i)}}
+  end
+  after(:all) do
+    @db.drop_table(:test) rescue nil
+  end
+  
+    specify "should return the same results as the non-cursor use" do
+      @ds.all.should == @ds.use_cursor.all
+    end
+    
+    specify "should respect the :rows_per_fetch option" do
+      @db.sqls.clear
+      @ds.use_cursor.all
+      @db.sqls.length.should == 6
+      @db.sqls.clear
+      @ds.use_cursor(:rows_per_fetch=>100).all
+      @db.sqls.length.should == 15
+    end
+    
+    specify "should handle returning inside block" do
+      def @ds.check_return
+        use_cursor.each{|r| return}
+      end
+      @ds.check_return
+      @ds.all.should == @ds.use_cursor.all
+    end
+end
+end

data/spec/adapters/sqlite_spec.rb

@@ -241,6 +241,16 @@ context "SQLite dataset" do
     SQLITE_DB[:test].select(:name, :value).order(:value).to_a.should == \
       @d.select(:name, :value).order(:value).to_a
   end
+    
+  specify "should support #explain" do
+    SQLITE_DB[:test].explain.should be_a_kind_of(Array)
+  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)
+  end
 end
 
 context "A SQLite database" do

data/spec/core/core_sql_spec.rb

@@ -82,6 +82,15 @@ context "String#lit" do
     ds.quote_identifiers = true
     ds.literal(a).should == 'DISTINCT "a"'
   end
+  
+  specify "should handle named placeholders if given a single argument hash" do
+    a = 'DISTINCT :b'.lit(:b=>:a)
+    a.should be_a_kind_of(Sequel::SQL::PlaceholderLiteralString)
+    ds = MockDatabase.new.dataset
+    ds.literal(a).should == 'DISTINCT a'
+    ds.quote_identifiers = true
+    ds.literal(a).should == 'DISTINCT "a"'
+  end
 end
 
 context "String#to_sequel_blob" do

data/spec/core/database_spec.rb

@@ -1027,12 +1027,16 @@ context "Database#fetch" do
     @db.fetch('select * from xyz where x = ? and y = ?', 15, 'abc') {|r| sql = r[:sql]}
     sql.should == "select * from xyz where x = 15 and y = 'abc'"
     
-    # and Aman Gupta's example
-    @db.fetch('select name from table where name = ? or id in ?',
-    'aman', [3,4,7]) {|r| sql = r[:sql]}
+    @db.fetch('select name from table where name = ? or id in ?', 'aman', [3,4,7]) {|r| sql = r[:sql]}
     sql.should == "select name from table where name = 'aman' or id in (3, 4, 7)"
   end
   
+  specify "should format the given sql with named arguments" do
+    sql = nil
+    @db.fetch('select * from xyz where x = :x and y = :y', :x=>15, :y=>'abc') {|r| sql = r[:sql]}
+    sql.should == "select * from xyz where x = 15 and y = 'abc'"
+  end
+  
   specify "should return the dataset if no block is given" do
     @db.fetch('select * from xyz').should be_a_kind_of(Sequel::Dataset)
     
@@ -1065,7 +1069,7 @@ context "Database#[]" do
     ds.opts[:from].should == [:items]
   end
   
-  specify "should return an enumerator when a string is given" do
+  specify "should return a dataset when a string is given" do
     c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql); yield({:sql => sql}); end
     end

data/spec/core/dataset_spec.rb

@@ -300,15 +300,44 @@ context "Dataset#where" do
       should match(/WHERE \(\(name = 'xyz'\) AND \(price = 342\)\)|WHERE \(\(price = 342\) AND \(name = 'xyz'\)\)/)
   end
   
-  specify "should work with arrays (ala ActiveRecord)" do
+  specify "should work with a string with placeholders and arguments for those placeholders" do
     @dataset.where('price < ? AND id in ?', 100, [1, 2, 3]).select_sql.should ==
       "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
   end
   
+  specify "should not modify passed array with placeholders" do
+    a = ['price < ? AND id in ?', 100, 1, 2, 3]
+    b = a.dup
+    @dataset.where(a)
+    b.should == a
+  end
+
   specify "should work with strings (custom SQL expressions)" do
     @dataset.where('(a = 1 AND b = 2)').select_sql.should ==
       "SELECT * FROM test WHERE ((a = 1 AND b = 2))"
   end
+    
+  specify "should work with a string with named placeholders and a hash of placeholder value arguments" do
+    @dataset.where('price < :price AND id in :ids', :price=>100, :ids=>[1, 2, 3]).select_sql.should ==
+      "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
+  end
+    
+  specify "should not modify passed array with named placeholders" do
+    a = ['price < :price AND id in :ids', {:price=>100}]
+    b = a.dup
+    @dataset.where(a)
+    b.should == a
+  end
+
+  specify "should not replace named placeholders that don't existin in the hash" do
+    @dataset.where('price < :price AND id in :ids', :price=>100).select_sql.should ==
+      "SELECT * FROM test WHERE (price < 100 AND id in :ids)"
+  end
+    
+  specify "should handle partial names" do
+    @dataset.where('price < :price AND id = :p', :p=>2, :price=>100).select_sql.should ==
+      "SELECT * FROM test WHERE (price < 100 AND id = 2)"
+  end
   
   specify "should affect select, delete and update statements" do
     @d1.select_sql.should == "SELECT * FROM test WHERE (region = 'Asia')"
@@ -626,10 +655,6 @@ context "Dataset#having" do
     @columns = "region, sum(population), avg(gdp)"
   end
 
-  specify "should raise if the dataset is not grouped" do
-    proc {@dataset.having('avg(gdp) > 10')}.should raise_error(Sequel::InvalidOperation)
-  end
-
   specify "should affect select statements" do
     @d1.select_sql.should ==
       "SELECT #{@columns} FROM test GROUP BY region HAVING (sum(population) > 10)"
@@ -768,8 +793,20 @@ context "Dataset#literal" do
     @dataset.literal(:items__name).should == "items.name"
   end
   
-  specify "should raise an error for unsupported types" do
-    proc {@dataset.literal({})}.should raise_error
+  specify "should call sql_literal with dataset on type if not natively supported and the object responds to it" do
+    @a = Class.new do
+      def sql_literal(ds)
+        "called #{ds.blah}"
+      end
+    end
+    def @dataset.blah
+      "ds"
+    end
+    @dataset.literal(@a.new).should == "called ds"
+  end
+  
+  specify "should raise an error for unsupported types with no sql_literal method" do
+    proc {@dataset.literal(Object.new)}.should raise_error
   end
   
   specify "should literalize datasets as subqueries" do
@@ -1106,10 +1143,18 @@ context "Dataset#with_sql" do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
-  specify "should remove use static sql" do
+  specify "should use static sql" do
     @dataset.with_sql('SELECT 1 FROM test').sql.should == 'SELECT 1 FROM test'
   end
   
+  specify "should work with placeholders" do
+    @dataset.with_sql('SELECT ? FROM test', 1).sql.should == 'SELECT 1 FROM test'
+  end
+
+  specify "should work with named placeholders" do
+    @dataset.with_sql('SELECT :x FROM test', :x=>1).sql.should == 'SELECT 1 FROM test'
+  end
+
   specify "should keep row_proc" do
     @dataset.with_sql('SELECT 1 FROM test').row_proc.should == @dataset.row_proc
   end
@@ -1440,6 +1485,11 @@ context "Dataset#group_and_count" do
     @ds.group_and_count(:a, :b).sql.should == 
       "SELECT a, b, count(*) AS count FROM test GROUP BY a, b ORDER BY count"
   end
+
+  specify "should format column aliases in the select clause but not in the group clause" do
+    @ds.group_and_count(:name___n).sql.should ==
+      "SELECT name AS n, count(*) AS count FROM test GROUP BY name ORDER BY count"
+  end
 end
 
 context "Dataset#empty?" do
@@ -1511,38 +1561,54 @@ context "Dataset#join_table" do
       'SELECT * FROM "items" INNER JOIN "b" ON ("b"."items_id" = "items"."id") LEFT OUTER JOIN "c" ON ("c"."b_id" = "b"."id")'
   end
   
-  specify "should support left outer joins" do
-    @d.join_table(:left_outer, :categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+  specify "should support arbitrary join types" do
+    @d.join_table(:magic, :categories, :category_id=>:id).sql.should ==
+      'SELECT * FROM "items" MAGIC JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+  end
 
+  specify "should support many join methods" do
     @d.left_outer_join(:categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-  end
-
-  specify "should support right outer joins" do
-    @d.join_table(:right_outer, :categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-
     @d.right_outer_join(:categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-  end
-
-  specify "should support full outer joins" do
-    @d.join_table(:full_outer, :categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-
     @d.full_outer_join(:categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-  end
-
-  specify "should support inner joins" do
-    @d.join_table(:inner, :categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-
     @d.inner_join(:categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.left_join(:categories, :category_id=>:id).sql.should ==
+      'SELECT * FROM "items" LEFT JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.right_join(:categories, :category_id=>:id).sql.should ==
+      'SELECT * FROM "items" RIGHT JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.full_join(:categories, :category_id=>:id).sql.should ==
+      'SELECT * FROM "items" FULL JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.natural_join(:categories).sql.should ==
+      'SELECT * FROM "items" NATURAL JOIN "categories"'
+    @d.natural_left_join(:categories).sql.should ==
+      'SELECT * FROM "items" NATURAL LEFT JOIN "categories"'
+    @d.natural_right_join(:categories).sql.should ==
+      'SELECT * FROM "items" NATURAL RIGHT JOIN "categories"'
+    @d.natural_full_join(:categories).sql.should ==
+      'SELECT * FROM "items" NATURAL FULL JOIN "categories"'
+    @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)
+  end
+
+  specify "should raise an error if blocks are provided to join methods that don't pass them" do
+    proc{@d.natural_join(:categories){}}.should raise_error(Sequel::Error)
+    proc{@d.natural_left_join(:categories){}}.should raise_error(Sequel::Error)
+    proc{@d.natural_right_join(:categories){}}.should raise_error(Sequel::Error)
+    proc{@d.natural_full_join(:categories){}}.should raise_error(Sequel::Error)
+    proc{@d.cross_join(:categories){}}.should raise_error(Sequel::Error)
+  end
+
   specify "should default to a plain join if nil is used for the type" do
     @d.join_table(nil, :categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items"  JOIN "categories" ON ("categories"."category_id" = "items"."id")'
@@ -1680,6 +1746,11 @@ context "Dataset#join_table" do
       'SELECT * FROM "items" INNER JOIN "categories" USING ("id1", "id2")'
   end
 
+  specify "should emulate JOIN USING (poorly) if the dataset doesn't support it" do
+    @d.meta_def(:supports_join_using?){false}
+    @d.join(:categories, [:id]).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."id" = "items"."id")'
+  end
+
   specify "should raise an error if using an array of symbols with a block" do
     proc{@d.join(:categories, [:id]){|j,lj,js|}}.should raise_error(Sequel::Error)
   end
@@ -1852,6 +1923,14 @@ context "Dataset aggregate methods" do
   specify "should accept qualified columns" do
     @d.avg(:test__bc).should == 'SELECT avg(test.bc) FROM test LIMIT 1'
   end
+  
+  specify "should use a subselect for the same conditions as count" do
+    d = @d.order(:a).limit(5)
+    d.avg(:a).should == 'SELECT avg(a) FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
+    d.sum(:a).should == 'SELECT sum(a) FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
+    d.min(:a).should == 'SELECT min(a) FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
+    d.max(:a).should == 'SELECT max(a) FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
+  end
 end
 
 context "Dataset#range" do
@@ -1880,6 +1959,11 @@ context "Dataset#range" do
   specify "should return a range object" do
     @d.range(:tryme).should == (1..10)
   end
+  
+  specify "should use a subselect for the same conditions as count" do
+    @d.order(:stamp).limit(5).range(:stamp).should == (1..10)
+    @d.last_sql.should == 'SELECT min(stamp) AS v1, max(stamp) AS v2 FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1'
+  end
 end
 
 context "Dataset#interval" do
@@ -1908,6 +1992,11 @@ context "Dataset#interval" do
   specify "should return an integer" do
     @d.interval(:tryme).should == 1234
   end
+  
+  specify "should use a subselect for the same conditions as count" do
+    @d.order(:stamp).limit(5).interval(:stamp).should == 1234
+    @d.last_sql.should == 'SELECT (max(stamp) - min(stamp)) FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1'
+  end
 end
 
 context "Dataset #first and #last" do
@@ -3080,6 +3169,10 @@ context "Sequel::Dataset#qualify_to_first_source" do
     @ds.filter('? > ?', :a, 1).qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE (t.a > 1)'
   end
 
+  specify "should handle SQL::PlaceholderLiteralStrings with named placeholders" 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::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'

data/spec/core/expression_filters_spec.rb

@@ -327,6 +327,17 @@ context "Blockless Ruby Filters" do
     @d.l([[:x, nil], [:y, [1,2,3]]].sql_or).should == '((x IS NULL) OR (y IN (1, 2, 3)))'
   end
   
+  it "should emulate columns for array values" do
+    @d.l([:x, :y]=>[[1,2], [3,4]].sql_array).should == '((x, y) IN ((1, 2), (3, 4)))'
+    @d.l([:x, :y, :z]=>[[1,2,5], [3,4,6]]).should == '((x, y, z) IN ((1, 2, 5), (3, 4, 6)))'
+  end
+  
+  it "should emulate multiple column in if not supported" do
+    @d.meta_def(:supports_multiple_column_in?){false}
+    @d.l([:x, :y]=>[[1,2], [3,4]].sql_array).should == '(((x = 1) AND (y = 2)) OR ((x = 3) AND (y = 4)))'
+    @d.l([:x, :y, :z]=>[[1,2,5], [3,4,6]]).should == '(((x = 1) AND (y = 2) AND (z = 5)) OR ((x = 3) AND (y = 4) AND (z = 6)))'
+  end
+  
   it "should support Array#sql_string_join for concatenation of SQL strings" do
     @d.lit([:x].sql_string_join).should == '(x)'
     @d.lit([:x].sql_string_join(', ')).should == '(x)'
@@ -533,4 +544,10 @@ context Sequel::SQL::VirtualRow do
     proc{@d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}}.should raise_error(Sequel::Error)
     proc{Sequel::Dataset.new(nil).filter{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.sql}.should raise_error(Sequel::Error)
   end
+  
+  it "should deal with classes without requiring :: prefix" do
+    @d.l{date < Date.today}.should == "(\"date\" < '#{Date.today}')"
+    @d.l{date < Sequel::CURRENT_DATE}.should == "(\"date\" < CURRENT_DATE)"
+    @d.l{num < Math::PI.to_i}.should == "(\"num\" < 3)"
+  end
 end