sequel 3.30.0 → 3.31.0

data/spec/core/database_spec.rb

@@ -571,11 +571,7 @@ describe "Database#table_exists?" do
   end
 end
 
-describe "Database#transaction" do
-  before do
-    @db = Sequel.mock(:servers=>{:test=>{}})
-  end
-  
+shared_examples_for "Database#transaction" do  
   specify "should wrap the supplied block with BEGIN + COMMIT statements" do
     @db.transaction{@db.execute 'DROP TABLE test;'}
     @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
@@ -699,7 +695,7 @@ describe "Database#transaction" do
     q1.pop
     cc.should be_a_kind_of(Sequel::Mock::Connection)
     tr = @db.instance_variable_get(:@transactions)
-    tr.should == {cc=>{:savepoint_level=>1}}
+    tr.keys.should == [cc]
     q.push nil
     t.join
     tr.should be_empty
@@ -796,6 +792,26 @@ describe "Database#transaction" do
     @db.sqls.should == ['BEGIN', 'ROLLBACK', 'foo']
   end
 
+  specify "should raise an error if you attempt to use after_commit inside a prepared transaction" do
+    @db.meta_def(:supports_prepared_transactions?){true}
+    proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{@db.execute('foo')}}}.should raise_error(Sequel::Error)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+  end
+
+  specify "should raise an error if you attempt to use after_rollback inside a prepared transaction" do
+    @db.meta_def(:supports_prepared_transactions?){true}
+    proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{@db.execute('foo')}}}.should raise_error(Sequel::Error)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+  end
+end
+
+describe "Database#transaction with savepoint support" do
+  before do
+    @db = Sequel.mock(:servers=>{:test=>{}})
+  end
+
+  it_should_behave_like "Database#transaction"
+
   specify "should support after_commit inside savepoints" do
     @db.meta_def(:supports_savepoints?){true}
     @db.transaction do
@@ -817,18 +833,6 @@ describe "Database#transaction" do
     @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'RELEASE SAVEPOINT autopoint_1', 'ROLLBACK', 'foo', 'bar', 'baz']
   end
 
-  specify "should raise an error if you attempt to use after_commit inside a prepared transaction" do
-    @db.meta_def(:supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{@db.execute('foo')}}}.should raise_error(Sequel::Error)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-  end
-
-  specify "should raise an error if you attempt to use after_rollback inside a prepared transaction" do
-    @db.meta_def(:supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{@db.execute('foo')}}}.should raise_error(Sequel::Error)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-  end
-
   specify "should raise an error if you attempt to use after_commit inside a savepoint in a prepared transaction" do
     @db.meta_def(:supports_savepoints?){true}
     @db.meta_def(:supports_prepared_transactions?){true}
@@ -843,7 +847,16 @@ describe "Database#transaction" do
     @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
   end
 end
+  
+describe "Database#transaction without savepoint support" do
+  before do
+    @db = Sequel.mock(:servers=>{:test=>{}})
+    @db.meta_def(:supports_savepoints?){false}
+  end
 
+  it_should_behave_like "Database#transaction"
+end
+  
 describe "Sequel.transaction" do
   before do
     @sqls = []

data/spec/core/dataset_spec.rb

@@ -342,12 +342,12 @@ describe "Dataset#exists" do
     @ds1.filter(@ds2.exists).sql.should ==
       'SELECT * FROM test WHERE (EXISTS (SELECT * FROM test WHERE (price < 100)))'
     @ds1.filter(@ds2.exists & @ds3.exists).sql.should ==
-      'SELECT * FROM test WHERE (EXISTS (SELECT * FROM test WHERE (price < 100)) AND EXISTS (SELECT * FROM test WHERE (price > 50)))'
+      'SELECT * FROM test WHERE ((EXISTS (SELECT * FROM test WHERE (price < 100))) AND (EXISTS (SELECT * FROM test WHERE (price > 50))))'
   end
 
   specify "should work in select" do
     @ds1.select(@ds2.exists.as(:a), @ds3.exists.as(:b)).sql.should ==
-      'SELECT EXISTS (SELECT * FROM test WHERE (price < 100)) AS a, EXISTS (SELECT * FROM test WHERE (price > 50)) AS b FROM test'
+      'SELECT (EXISTS (SELECT * FROM test WHERE (price < 100))) AS a, (EXISTS (SELECT * FROM test WHERE (price > 50))) AS b FROM test'
   end
 end
 
@@ -844,7 +844,7 @@ end
 
 describe "Dataset#group_by" do
   before do
-    @dataset = Sequel::Dataset.new(nil).from(:test).group_by(:type_id)
+    @dataset = Sequel.mock[:test].group_by(:type_id)
   end
 
   specify "should raise when trying to generate an update statement" do
@@ -881,6 +881,23 @@ describe "Dataset#group_by" do
     @dataset.group{[type_id > 1, type_id < 2]}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1), (type_id < 2)"
     @dataset.group(:foo){type_id > 1}.sql.should == "SELECT * FROM test GROUP BY foo, (type_id > 1)"
   end
+
+  specify "should support a #group_rollup method if the database supports it" do
+    @dataset.meta_def(:supports_group_rollup?){true}
+    @dataset.group(:type_id).group_rollup.select_sql.should == "SELECT * FROM test GROUP BY ROLLUP(type_id)"
+    @dataset.group(:type_id, :b).group_rollup.select_sql.should == "SELECT * FROM test GROUP BY ROLLUP(type_id, b)"
+  end
+
+  specify "should support a #group_cube method if the database supports it" do
+    @dataset.meta_def(:supports_group_cube?){true}
+    @dataset.group(:type_id).group_cube.select_sql.should == "SELECT * FROM test GROUP BY CUBE(type_id)"
+    @dataset.group(:type_id, :b).group_cube.select_sql.should == "SELECT * FROM test GROUP BY CUBE(type_id, b)"
+  end
+
+  specify "should have #group_cube and #group_rollup methods raise an Error if not supported it" do
+    proc{@dataset.group(:type_id).group_rollup}.should raise_error(Sequel::Error)
+    proc{@dataset.group(:type_id).group_cube}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "Dataset#as" do
@@ -930,6 +947,21 @@ describe "Dataset#literal" do
     @dataset.literal(:"items__na#m$e").should == "items.na#m$e"
   end
 
+  specify "should call sql_literal_append with dataset and sql on type if not natively supported and the object responds to it" do
+    @a = Class.new do
+      def sql_literal_append(ds, sql)
+        sql << "called #{ds.blah}"
+      end
+      def sql_literal(ds)
+        "not called #{ds.blah}"
+      end
+    end
+    def @dataset.blah
+      "ds"
+    end
+    @dataset.literal(@a.new).should == "called ds"
+  end
+  
   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)
@@ -1033,10 +1065,9 @@ describe "Dataset#literal" do
   end
   
   specify "should not modify literal strings" do
+    @dataset.quote_identifiers = true
     @dataset.literal('col1 + 2'.lit).should == 'col1 + 2'
-    
-    @dataset.update_sql(:a => 'a + 2'.lit).should == 
-      'UPDATE test SET a = a + 2'
+    @dataset.update_sql(Sequel::SQL::Identifier.new('a'.lit) => 'a + 2'.lit).should == 'UPDATE "test" SET a = a + 2'
   end
 
   specify "should literalize BigDecimal instances correctly" do
@@ -1103,6 +1134,10 @@ describe "Dataset#from" do
     @dataset.from(:'#___#').select_sql.should == 'SELECT * FROM # AS #'
   end
 
+  specify "should not handle :foo__schema__table___alias specially" do
+    @dataset.from(:foo__schema__table___alias).select_sql.should == "SELECT * FROM foo.schema__table AS alias"
+  end
+
   specify "should hoist WITH clauses from subqueries if the dataset doesn't support CTEs in subselects" do
     @dataset.meta_def(:supports_cte?){true}
     @dataset.meta_def(:supports_cte_in_subselect?){false}
@@ -1770,9 +1805,9 @@ describe "Dataset#empty?" do
   specify "should return true if records exist in the dataset" do
     db = Sequel.mock(:fetch=>proc{|sql| {1=>1} unless sql =~ /WHERE 'f'/})
     db.from(:test).should_not be_empty
-    db.sqls.should == ['SELECT 1 FROM test LIMIT 1']
+    db.sqls.should == ['SELECT 1 AS one FROM test LIMIT 1']
     db.from(:test).filter(false).should be_empty
-    db.sqls.should == ["SELECT 1 FROM test WHERE 'f' LIMIT 1"]
+    db.sqls.should == ["SELECT 1 AS one FROM test WHERE 'f' LIMIT 1"]
   end
 end
 
@@ -1819,9 +1854,9 @@ describe "Dataset#first_source_table" do
   end
   
   specify "should be the unaliased part if aliased" do
-    @ds.from(:t___a).first_source_table.should == :t.identifier
-    @ds.from(:s__t___a).first_source_table.should == :t.qualify(:s)
-    @ds.from(:t.as(:a)).first_source_table.should == :t
+    @ds.literal(@ds.from(:t___a).first_source_table).should == "t"
+    @ds.literal(@ds.from(:s__t___a).first_source_table).should == "s.t"
+    @ds.literal(@ds.from(:t.as(:a)).first_source_table).should == "t"
   end
   
   specify "should raise exception if table doesn't have a source" do
@@ -2145,7 +2180,7 @@ end
 
 describe "Dataset#insert_multiple" do
   before do
-    @db = Sequel.mock
+    @db = Sequel.mock(:autoid=>2)
     @ds = @db[:items]
   end
   
@@ -2163,6 +2198,10 @@ describe "Dataset#insert_multiple" do
       "INSERT INTO items VALUES ('herro')",
       "INSERT INTO items VALUES ('the ticking crock')"]
   end
+
+  specify "should return array of inserted ids" do
+    @ds.insert_multiple(['aa', 5, 3, {:a => 2}]).should == [2, 3, 4, 5]
+  end
 end
 
 describe "Dataset aggregate methods" do
@@ -2588,6 +2627,11 @@ describe "Dataset#import" do
     @ds = @db[:items]
   end
   
+  specify "should return nil without a query if no values" do
+    @ds.import(['x', 'y'], []).should == nil
+    @db.sqls.should == []
+  end
+
   specify "should accept string keys as column names" do
     @ds.import(['x', 'y'], [[1, 2], [3, 4]])
     @db.sqls.should == ['BEGIN',
@@ -2635,11 +2679,16 @@ end
 
 describe "Dataset#multi_insert" do
   before do
-    @db = Sequel.mock
+    @db = Sequel.mock(:servers=>{:s1=>{}})
     @ds = @db[:items]
     @list = [{:name => 'abc'}, {:name => 'def'}, {:name => 'ghi'}]
   end
   
+  specify "should return nil without a query if no values" do
+    @ds.multi_insert([]).should == nil
+    @db.sqls.should == []
+  end
+
   specify "should issue multiple insert statements inside a transaction" do
     @ds.multi_insert(@list)
     @db.sqls.should == ['BEGIN',
@@ -2649,6 +2698,34 @@ describe "Dataset#multi_insert" do
       'COMMIT']
   end
   
+  specify "should respect :server option" do
+    @ds.multi_insert(@list, :server=>:s1)
+    @db.sqls.should == ['BEGIN -- s1',
+      "INSERT INTO items (name) VALUES ('abc') -- s1",
+      "INSERT INTO items (name) VALUES ('def') -- s1",
+      "INSERT INTO items (name) VALUES ('ghi') -- s1",
+      'COMMIT -- s1']
+  end
+  
+  specify "should respect existing :server option on dataset" do
+    @ds.server(:s1).multi_insert(@list)
+    @db.sqls.should == ['BEGIN -- s1',
+      "INSERT INTO items (name) VALUES ('abc') -- s1",
+      "INSERT INTO items (name) VALUES ('def') -- s1",
+      "INSERT INTO items (name) VALUES ('ghi') -- s1",
+      'COMMIT -- s1']
+  end
+  
+  specify "should respect :return=>:primary_key option" do
+    @db.autoid = 1
+    @ds.multi_insert(@list, :return=>:primary_key).should == [1, 2, 3]
+    @db.sqls.should == ['BEGIN',
+      "INSERT INTO items (name) VALUES ('abc')",
+      "INSERT INTO items (name) VALUES ('def')",
+      "INSERT INTO items (name) VALUES ('ghi')",
+      'COMMIT']
+  end
+  
   specify "should handle different formats for tables" do
     @ds = @ds.from(:sch__tab)
     @ds.multi_insert(@list)

data/spec/core/mock_adapter_spec.rb

@@ -126,6 +126,11 @@ describe "Sequel Mock Adapter" do
     rs.should == [{:a=>1}, {:b=>2}]
   end
 
+  specify "should raise Error if given an invalid object to fetch" do
+    proc{Sequel.mock(:fetch=>Class.new).get(1)}.should raise_error(Sequel::Error)
+    proc{Sequel.mock(:fetch=>Object.new).get(1)}.should raise_error(Sequel::Error)
+  end
+
   specify "should be able to set the number of rows modified by update and delete using :numrows option as an integer" do
     db = Sequel.mock(:numrows=>2)
     db[:t].update(:a=>1).should == 2
@@ -188,6 +193,13 @@ describe "Sequel Mock Adapter" do
     ds.delete.should == 3
   end
 
+  specify "should raise Error if given an invalid object for numrows or autoid" do
+    proc{Sequel.mock(:numrows=>Class.new)[:a].delete}.should raise_error(Sequel::Error)
+    proc{Sequel.mock(:numrows=>Object.new)[:a].delete}.should raise_error(Sequel::Error)
+    proc{Sequel.mock(:autoid=>Class.new)[:a].insert}.should raise_error(Sequel::Error)
+    proc{Sequel.mock(:autoid=>Object.new)[:a].insert}.should raise_error(Sequel::Error)
+  end
+
   specify "should be able to set the autogenerated primary key returned by insert using :autoid option as an integer" do
     db = Sequel.mock(:autoid=>1)
     db[:t].insert(:a=>1).should == 1
@@ -279,6 +291,19 @@ describe "Sequel Mock Adapter" do
     db[:t].columns.should == [:c, :d]
   end
 
+  specify "should raise Error if given an invalid columns" do
+    proc{Sequel.mock(:columns=>Object.new)[:a].columns}.should raise_error(Sequel::Error)
+  end
+
+  specify "should not quote identifiers by default" do
+    Sequel.mock.send(:quote_identifiers_default).should be_false
+  end
+
+  specify "should not have identifier input/output methods by default" do
+    Sequel.mock.send(:identifier_input_method_default).should be_nil
+    Sequel.mock.send(:identifier_output_method_default).should be_nil
+  end
+
   specify "should keep a record of all executed SQL in #sqls" do
     db = Sequel.mock
     db[:t].all
@@ -379,4 +404,16 @@ describe "Sequel Mock Adapter" do
     ds.should be_a_kind_of(Sequel::Mock::Dataset)
     ds.columns.should == [:id, :a, :b]
   end
+
+  specify "should be able to load dialects based on the database name" do
+    Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.should == 'SELECT #2011-12-13#'
+    Sequel.mock(:host=>'db2').select(1).sql.should == 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
+    Sequel.mock(:host=>'firebird')[:a].distinct.limit(1, 2).sql.should == 'SELECT DISTINCT FIRST 1 SKIP 2 * FROM a'
+    Sequel.mock(:host=>'informix')[:a].distinct.limit(1, 2).sql.should == 'SELECT SKIP 2 FIRST 1 DISTINCT * FROM a'
+    Sequel.mock(:host=>'mssql', :quote_identifiers=>true, :identifier_input_method=>:upcase)[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
+    Sequel.mock(:host=>'mysql', :quote_identifiers=>true)[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
+    Sequel.mock(:host=>'oracle', :quote_identifiers=>true)[:a].limit(1).sql.should == 'SELECT * FROM (SELECT * FROM "a") "t1" WHERE (ROWNUM <= 1)'
+    Sequel.mock(:host=>'postgres', :quote_identifiers=>true)[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM \"a\" WHERE (to_tsvector('simple', (COALESCE(\"b\", ''))) @@ to_tsquery('simple', 'c'))"
+    Sequel.mock(:host=>'sqlite', :quote_identifiers=>true)[:a___b].sql.should == "SELECT * FROM `a` AS 'b'"
+  end
 end

data/spec/extensions/instance_filters_spec.rb

@@ -7,6 +7,7 @@ describe "instance_filters plugin" do
     @c.columns :id, :name, :num
     @c.plugin :instance_filters
     @p = @c.load(:id=>1, :name=>'John', :num=>1)
+    MODEL_DB.sqls
   end
 
   specify "should raise an error when updating a stale record" do

data/spec/extensions/nested_attributes_spec.rb

@@ -148,7 +148,7 @@ describe "NestedAttributes plugin" do
     @db.sqls.should == []
     @Album.dataset._fetch = {:id=>1}
     ar.save
-    check_sql_array("SELECT 1 FROM albums WHERE ((albums.artist_id = 20) AND (id = 10)) LIMIT 1",
+    check_sql_array("SELECT 1 AS one FROM albums WHERE ((albums.artist_id = 20) AND (id = 10)) LIMIT 1",
       ["UPDATE albums SET artist_id = NULL, name = 'Al' WHERE (id = 10)", "UPDATE albums SET name = 'Al', artist_id = NULL WHERE (id = 10)"],
       "UPDATE artists SET name = 'Ar' WHERE (id = 20)")
   end

data/spec/extensions/serialization_spec.rb

@@ -37,11 +37,6 @@ describe "Serialization plugin" do
     MODEL_DB.sqls.map{|s| s.sub("...\n", '')}.should == ["INSERT INTO items (abc) VALUES ('--- 1\n')", "INSERT INTO items (abc) VALUES ('--- hello\n')"]
   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]
@@ -71,6 +66,12 @@ describe "Serialization plugin" do
     ]
   end
 
+  it "should allow serializing attributes using arbitrary callable" do
+    @c.plugin :serialization, [proc{|s| s.reverse}, proc{}], :abc
+    @c.create(:abc => "hello")
+    MODEL_DB.sqls.should == ["INSERT INTO items (abc) VALUES ('olleh')"]
+  end
+  
   it "should translate values to and from yaml serialization format using accessor methods" do
     @c.set_primary_key :id
     @c.plugin :serialization, :yaml, :abc, :def
@@ -133,6 +134,49 @@ describe "Serialization plugin" do
       "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
+  it "should translate values to and from arbitrary callables using accessor methods" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, [proc{|s| s.reverse}, proc{|s| s.reverse}], :abc, :def
+    @c.dataset._fetch = {:id => 1, :abc => 'cba', :def => 'olleh'}
+    
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 'abc'
+    o.abc.should == 'abc'
+    o.def.should == "hello"
+    o.def.should == "hello"
+    
+    o.update(:abc => 'foo')
+    @c.create(:abc => 'bar')
+    
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = 'oof' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('rab')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+  end
+
+  it "should handle registration of custom serializer/deserializer pairs" do
+    @c.set_primary_key :id
+    Sequel::Plugins::Serialization.register_format(:reverse, proc{|s| s.reverse}, proc{|s| s.reverse})
+    @c.plugin :serialization, :reverse, :abc, :def
+    @c.dataset._fetch = {:id => 1, :abc => 'cba', :def => 'olleh'}
+    
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 'abc'
+    o.abc.should == 'abc'
+    o.def.should == "hello"
+    o.def.should == "hello"
+    
+    o.update(:abc => 'foo')
+    @c.create(:abc => 'bar')
+    
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = 'oof' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('rab')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+  end
+
   it "should copy serialization formats and columns to subclasses" do
     @c.set_primary_key :id
     @c.plugin :serialization, :yaml, :abc, :def

data/spec/extensions/sharding_spec.rb

@@ -172,7 +172,7 @@ describe "sharding plugin" do
     # Should select from current object's shard to check existing association, but update associated object's shard
     sqls = @db.sqls
     ["UPDATE albums SET artist_id = NULL, name = 'T' WHERE (id = 5) -- s4", "UPDATE albums SET name = 'T', artist_id = NULL WHERE (id = 5) -- s4"].should include(sqls.pop)
-    sqls.should == ["SELECT 1 FROM albums WHERE ((albums.artist_id = 2) AND (id = 5)) LIMIT 1 -- s2"]
+    sqls.should == ["SELECT 1 AS one FROM albums WHERE ((albums.artist_id = 2) AND (id = 5)) LIMIT 1 -- s2"]
   end 
 
   specify "should be able to set a shard to use for any object using set_server" do

data/spec/integration/associations_test.rb

@@ -584,6 +584,21 @@ describe "Sequel::Model Simple Associations" do
     it_should_behave_like "eager limit strategies"
   end unless Sequel.guarded?(:mysql, :db2, :oracle)
 
+  specify "should handle many_to_one associations with same name as :key" do
+    Album.def_column_alias(:artist_id_id, :artist_id)
+    Album.many_to_one :artist_id, :key_column =>:artist_id, :class=>Artist
+    @album.update(:artist_id_id => @artist.id)
+    @album.artist_id.should == @artist
+
+    as = Album.eager(:artist_id).all
+    as.should == [@album]
+    as.map{|a| a.artist_id}.should == [@artist]
+
+    as = Album.eager_graph(:artist_id).all
+    as.should == [@album]
+    as.map{|a| a.artist_id}.should == [@artist]
+  end
+
   specify "should handle aliased tables when eager_graphing" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)