sequel 4.45.0 → 4.46.0

data/spec/core/placeholder_literalizer_spec.rb

@@ -53,8 +53,19 @@ describe "Dataset::PlaceholderLiteralizer" do
     loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
     loader.first(:id=>1).must_equal @h
     loader.first(Sequel.expr{a(b)}).must_equal @h
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1)", "SELECT * FROM items WHERE a(b)"]
+  end
+  
+  deprecated "should handle calls with a literal strings used as filter arguments" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
     loader.first("a = 1").must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1)", "SELECT * FROM items WHERE a(b)", "SELECT * FROM items WHERE (a = 1)"]
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
+  end
+  
+  it "should handle calls with a literal strings used as filter arguments" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
+    loader.first(Sequel.lit("a = 1")).must_equal @h
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
   end
   
   it "should handle calls with a placeholders used as right hand side of condition specifiers" do
@@ -72,13 +83,20 @@ describe "Dataset::PlaceholderLiteralizer" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE ((a = 1) AND (b = 1))", "SELECT * FROM items WHERE ((a = 2) AND (b = 2))"]
   end
   
-  it "should handle calls with a placeholder used multiple times in different capacities" do
+  deprecated "should handle calls with a placeholder used multiple times in different capacities" do
     loader = @c.loader(@ds){|pl, ds| a = pl.arg; ds.where(a).where(:b=>a)}
     loader.first("a = 1").must_equal @h
     loader.first(["a = ?", 2]).must_equal @h
     @db.sqls.must_equal ["SELECT * FROM items WHERE ((a = 1) AND (b = 'a = 1'))", "SELECT * FROM items WHERE ((a = 2) AND (b IN ('a = ?', 2)))"]
   end
   
+  it "should handle calls with a placeholder used multiple times in different capacities" do
+    loader = @c.loader(@ds){|pl, ds| a = pl.arg; ds.select(a).where(:b=>a)}
+    loader.first("a").must_equal @h
+    loader.first(["a = ?", 2]).must_equal @h
+    @db.sqls.must_equal ["SELECT 'a' FROM items WHERE (b = 'a')", "SELECT ('a = ?', 2) FROM items WHERE (b IN ('a = ?', 2))"]
+  end
+  
   it "should handle calls with manually specified argument positions" do
     loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg(1)).where(:b=>pl.arg(0))}
     loader.first(1, 2).must_equal @h

data/spec/core/schema_generator_spec.rb

@@ -1,8 +1,8 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
-describe Sequel::Schema::Generator do
+describe Sequel::Schema::CreateTableGenerator do
   before do
-    @generator = Sequel::Schema::Generator.new(Sequel.mock) do
+    @generator = Sequel::Schema::CreateTableGenerator.new(Sequel.mock) do
       string :title
       column :body, :text
       foreign_key :parent_id
@@ -31,7 +31,7 @@ describe Sequel::Schema::Generator do
   end
   
   it "should respect existing column order if primary_key :keep_order is used" do
-    generator = Sequel::Schema::Generator.new(Sequel.mock) do
+    generator = Sequel::Schema::CreateTableGenerator.new(Sequel.mock) do
       string :title
       primary_key :id, :keep_order=>true
     end
@@ -44,7 +44,7 @@ describe Sequel::Schema::Generator do
   end
   
   it "should handle SQL::Identifier and SQL::QualifiedIdentifier as foreign_key arguments" do
-    generator = Sequel::Schema::Generator.new(Sequel.mock) do
+    generator = Sequel::Schema::CreateTableGenerator.new(Sequel.mock) do
       foreign_key :a_id, Sequel.identifier(:as)
       foreign_key :b_id, Sequel.qualify(:c, :b)
     end
@@ -182,9 +182,9 @@ describe Sequel::Schema::AlterTableGenerator do
   end
 end
 
-describe "Sequel::Schema::Generator generic type methods" do
+describe "Sequel::Schema::CreateTableGenerator generic type methods" do
   it "should store the type class in :type for each column" do
-    Sequel::Schema::Generator.new(Sequel.mock) do
+    Sequel::Schema::CreateTableGenerator.new(Sequel.mock) do
       String :a
       Integer :b
       Fixnum :c

data/spec/core/schema_spec.rb

@@ -10,13 +10,17 @@ describe "DB#create_table" do
     @db.sqls.must_equal ['CREATE TABLE cats ()']
   end
 
-  it "should accept the table name in multiple formats" do
+  with_symbol_splitting "should accept the table name with splittable symbols" do
     @db.create_table(:cats__cats) {}
+    @db.sqls.must_equal ['CREATE TABLE cats.cats ()']
+  end
+
+  it "should accept the table name in multiple formats" do
     @db.create_table(Sequel[:cats][:cats]) {}
     @db.create_table("cats__cats1") {}
     @db.create_table(Sequel.identifier(:cats__cats2)) {}
     @db.create_table(Sequel.qualify(:cats3, :cats)) {}
-    @db.sqls.must_equal ['CREATE TABLE cats.cats ()', 'CREATE TABLE cats.cats ()', 'CREATE TABLE cats__cats1 ()', 'CREATE TABLE cats__cats2 ()', 'CREATE TABLE cats3.cats ()']
+    @db.sqls.must_equal ['CREATE TABLE cats.cats ()', 'CREATE TABLE cats__cats1 ()', 'CREATE TABLE cats__cats2 ()', 'CREATE TABLE cats3.cats ()']
   end
 
   it "should raise an error if the table name argument is not valid" do
@@ -1495,9 +1499,12 @@ describe "Database#create_view" do
     @db.sqls.must_equal ['CREATE VIEW test AS SELECT a, b FROM items ORDER BY c WITH LOCAL CHECK OPTION']
   end
 
-  it "should handle create_or_replace_view" do
+  with_symbol_splitting "should handle create_or_replace_view with splittable symbols" do
     @db.create_or_replace_view :sch__test, "SELECT * FROM xyz"
     @db.sqls.must_equal ['DROP VIEW sch.test', 'CREATE VIEW sch.test AS SELECT * FROM xyz']
+  end
+
+  it "should handle create_or_replace_view" do
     @db.create_or_replace_view :test, @db[:items].select(:a, :b).order(:c)
     @db.sqls.must_equal ['DROP VIEW test', 'CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
     @db.create_or_replace_view Sequel.identifier(:test), @db[:items].select(:a, :b).order(:c)
@@ -1516,12 +1523,16 @@ describe "Database#drop_view" do
     @db = Sequel.mock
   end
   
+  with_symbol_splitting "should construct proper SQL for splittable symbols" do
+    @db.drop_view :sch__test
+    @db.sqls.must_equal ['DROP VIEW sch.test']
+  end
+
   it "should construct proper SQL" do
     @db.drop_view :test
     @db.drop_view Sequel.identifier(:test)
-    @db.drop_view :sch__test
     @db.drop_view Sequel.qualify(:sch, :test)
-    @db.sqls.must_equal ['DROP VIEW test', 'DROP VIEW test', 'DROP VIEW sch.test', 'DROP VIEW sch.test']
+    @db.sqls.must_equal ['DROP VIEW test', 'DROP VIEW test', 'DROP VIEW sch.test']
   end
 
   it "should drop multiple views at once" do
@@ -1589,6 +1600,19 @@ describe "Schema Parser" do
     end
     @db.schema(:x)
     c.must_equal ["x", {}]
+    @db.schema(Sequel[:s][:x])
+    c.must_equal ["x", {:schema=>"s"}]
+    ds = @db[Sequel[:s][:y]]
+    @db.schema(ds)
+    c.must_equal ["y", {:schema=>"s", :dataset=>ds}]
+  end
+
+  with_symbol_splitting "should provide options if given a table name with splittable symbols" do
+    c = nil
+    meta_def(@db, :schema_parse_table) do |t, opts|
+      c = [t, opts]
+      [[:a, {:db_type=>t.to_s}]]
+    end
     @db.schema(:s__x)
     c.must_equal ["x", {:schema=>"s"}]
     ds = @db[:s__y]
@@ -1646,6 +1670,31 @@ describe "Schema Parser" do
     @db.schema(:x).object_id.must_equal s1.object_id
     @db.schema(Sequel.identifier(:x)).object_id.must_equal s1.object_id
 
+    s2 = @db.schema(Sequel[:x][:y])
+    s2.must_equal [['y', {:schema=>'x', :ruby_default=>nil}]]
+    @db.schema(Sequel[:x][:y]).object_id.must_equal s2.object_id
+    @db.schema(Sequel.qualify(:x, :y)).object_id.must_equal s2.object_id
+
+    s2 = @db.schema(Sequel.qualify(:v, Sequel[:x][:y]))
+    s2.must_equal [['y', {:schema=>'x', :ruby_default=>nil, :information_schema_schema=>Sequel.identifier('v')}]]
+    @db.schema(Sequel.qualify(:v, Sequel[:x][:y])).object_id.must_equal s2.object_id
+    @db.schema(Sequel.qualify(Sequel[:v][:x], :y)).object_id.must_equal s2.object_id
+
+    s2 = @db.schema(Sequel.qualify(Sequel[:u][:v], Sequel[:x][:y]))
+    s2.must_equal [['y', {:schema=>'x', :ruby_default=>nil, :information_schema_schema=>Sequel.qualify('u', 'v')}]]
+    @db.schema(Sequel.qualify(Sequel[:u][:v], Sequel[:x][:y])).object_id.must_equal s2.object_id
+    @db.schema(Sequel.qualify(Sequel.qualify(:u, :v), Sequel.qualify(:x, :y))).object_id.must_equal s2.object_id
+  end
+
+  with_symbol_splitting "should convert splittable symbol arguments" do
+    meta_def(@db, :schema_parse_table) do |t, opts|
+      [[t, opts]]
+    end
+    s1 = @db.schema(:x)
+    s1.must_equal [['x', {:ruby_default=>nil}]]
+    @db.schema(:x).object_id.must_equal s1.object_id
+    @db.schema(Sequel.identifier(:x)).object_id.must_equal s1.object_id
+
     s2 = @db.schema(:x__y)
     s2.must_equal [['y', {:schema=>'x', :ruby_default=>nil}]]
     @db.schema(:x__y).object_id.must_equal s2.object_id

data/spec/core_extensions_spec.rb

@@ -6,9 +6,8 @@ if ENV['COVERAGE']
 end
 
 unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
-  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
+  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../lib/"))
   require 'sequel'
-  Sequel::Deprecation.backtrace_filter = true
 end
 
 # SEQUEL5: Remove
@@ -26,8 +25,13 @@ if RUBY_VERSION < '1.9.0'
   Sequel.extension :ruby18_symbol_extensions
 end
 Sequel.extension :symbol_aref
+Sequel.extension :virtual_row_method_block
 
+gem 'minitest'
 require 'minitest/autorun'
+require 'minitest/hooks/default'
+
+require File.expand_path("#{File.dirname(__FILE__)}/deprecation_helper.rb")
 
 describe "Sequel core extensions" do
   it "should have Sequel.core_extensions? be true if enabled" do
@@ -90,6 +94,9 @@ describe "Core extensions" do
   end
   it "should support NOT via Symbol#~" do
     @d.l(~:x).must_equal 'NOT x'
+  end
+
+  with_symbol_splitting "should support NOT via Symbol#~ for splittable symbols" do
     @d.l(~:x__y).must_equal 'NOT x.y'
   end
   
@@ -231,7 +238,7 @@ describe "Core extensions" do
     @d.lit([:x.sql_function(1), 'y.z'.lit].sql_string_join(', ')).must_equal "(x(1) || ', ' || y.z)"
     @d.lit([:x, 1, :y].sql_string_join).must_equal "(x || '1' || y)"
     @d.lit([:x, 1, :y].sql_string_join(', ')).must_equal "(x || ', ' || '1' || ', ' || y)"
-    @d.lit([:x, 1, :y].sql_string_join(:y__z)).must_equal "(x || y.z || '1' || y.z || y)"
+    @d.lit([:x, 1, :y].sql_string_join(Sequel[:y][:z])).must_equal "(x || y.z || '1' || y.z || y)"
     @d.lit([:x, 1, :y].sql_string_join(1)).must_equal "(x || '1' || '1' || '1' || y)"
     @d.lit([:x, :y].sql_string_join('y.x || x.y'.lit)).must_equal "(x || y.x || x.y || y)"
     @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).must_equal "(x || y || a || b)"
@@ -282,7 +289,7 @@ describe "Array#case and Hash#case" do
     @d.literal([[:x, :y]].case(:z)).must_equal '(CASE WHEN x THEN y ELSE z END)'
     @d.literal([[:x, :y], [:a, :b]].case(:z)).must_equal '(CASE WHEN x THEN y WHEN a THEN b ELSE z END)'
     @d.literal([[:x, :y], [:a, :b]].case(:z, :exp)).must_equal '(CASE exp WHEN x THEN y WHEN a THEN b ELSE z END)'
-    @d.literal([[:x, :y], [:a, :b]].case(:z, :exp__w)).must_equal '(CASE exp.w WHEN x THEN y WHEN a THEN b ELSE z END)'
+    @d.literal([[:x, :y], [:a, :b]].case(:z, Sequel[:exp][:w])).must_equal '(CASE exp.w WHEN x THEN y WHEN a THEN b ELSE z END)'
   end
 
   it "should return SQL CASE expression with expression even if nil" do
@@ -307,9 +314,9 @@ describe "Array#sql_value_list and #sql_array" do
   end
 
   it "should treat the array as an SQL value list instead of conditions when used as a placeholder value" do
-    @d.filter("(a, b) IN ?", [[:x, 1], [:y, 2]]).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x = 1) AND (y = 2)))'
-    @d.filter("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_value_list).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
-    @d.filter("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_array).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]])).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x = 1) AND (y = 2)))'
+    @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_value_list)).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_array)).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
   end
 
   it "should be no difference when used as a hash value" do
@@ -401,7 +408,9 @@ describe "#desc" do
   
   it "should format a DESC clause for a column ref" do
     @ds.literal(:test.desc).must_equal 'test DESC'
+  end
     
+  with_symbol_splitting "should format a DESC clause for a column ref with a splitting symbol" do
     @ds.literal(:items__price.desc).must_equal 'items.price DESC'
   end
 
@@ -417,7 +426,9 @@ describe "#asc" do
   
   it "should format a ASC clause for a column ref" do
     @ds.literal(:test.asc).must_equal 'test ASC'
+  end
     
+  with_symbol_splitting "should format a ASC clause for a column ref for a splittable symbol" do
     @ds.literal(:items__price.asc).must_equal 'items.price ASC'
   end
 
@@ -433,7 +444,9 @@ describe "#as" do
   
   it "should format a AS clause for a column ref" do
     @ds.literal(:test.as(:t)).must_equal 'test AS t'
-    
+  end  
+
+  with_symbol_splitting "should format a AS clause for a column ref for splittable symbols" do
     @ds.literal(:items__price.as(:p)).must_equal 'items.price AS p'
   end
 
@@ -453,15 +466,9 @@ describe "Column references" do
   
   it "should be quoted properly" do
     @ds.literal(:xyz).must_equal "`xyz`"
-    @ds.literal(:xyz__abc).must_equal "`xyz`.`abc`"
-
     @ds.literal(:xyz.as(:x)).must_equal "`xyz` AS `x`"
-    @ds.literal(:xyz__abc.as(:x)).must_equal "`xyz`.`abc` AS `x`"
-
-    @ds.literal(:xyz___x).must_equal "`xyz` AS `x`"
-    @ds.literal(:xyz__abc___x).must_equal "`xyz`.`abc` AS `x`"
   end
-  
+
   it "should be quoted properly in SQL functions" do
     @ds.literal(:avg.sql_function(:xyz)).must_equal "avg(`xyz`)"
     @ds.literal(:avg.sql_function(:xyz, 1)).must_equal "avg(`xyz`, 1)"
@@ -475,6 +482,13 @@ describe "Column references" do
   
   it "should be quoted properly in a cast function" do
     @ds.literal(:x.cast(:integer)).must_equal "CAST(`x` AS integer)"
+  end
+
+  with_symbol_splitting "should be quoted properly when using symbol splitting" do
+    @ds.literal(:xyz__abc).must_equal "`xyz`.`abc`"
+    @ds.literal(:xyz__abc.as(:x)).must_equal "`xyz`.`abc` AS `x`"
+    @ds.literal(:xyz___x).must_equal "`xyz` AS `x`"
+    @ds.literal(:xyz__abc___x).must_equal "`xyz`.`abc` AS `x`"
     @ds.literal(:x__y.cast('varchar(20)')).must_equal "CAST(`x`.`y` AS varchar(20))"
   end
 end
@@ -512,7 +526,7 @@ describe "Symbol#*" do
     @ds.literal(:abc.*(5)).must_equal '(abc * 5)'
   end
 
-  it "should support qualified symbols if no argument" do
+  with_symbol_splitting "should support qualified symbols if no argument" do
     @ds.literal(:xyz__abc.*).must_equal 'xyz.abc.*'
   end
 end
@@ -534,7 +548,7 @@ describe "Symbol" do
     @ds.literal(:xyz.qualify(:abc).qualify(:def)).must_equal '"def"."abc"."xyz"'
   end
 
-  it "should be able to qualify an identifier" do
+  with_symbol_splitting "should be able to qualify an identifier" do
     @ds.literal(:xyz.identifier.qualify(:xyz__abc)).must_equal '"xyz"."abc"."xyz"'
   end
 
@@ -575,11 +589,14 @@ describe "Symbol" do
 
   it "should support sql array accesses via sql_subscript" do
     @ds.literal(:abc.sql_subscript(1)).must_equal "abc[1]"
-    @ds.literal(:abc__def.sql_subscript(1)).must_equal "abc.def[1]"
     @ds.literal(:abc.sql_subscript(1)|2).must_equal "abc[1, 2]"
     @ds.literal(:abc.sql_subscript(1)[2]).must_equal "abc[1][2]"
   end
 
+  with_symbol_splitting "should support sql array accesses via sql_subscript for splittable symbols" do
+    @ds.literal(:abc__def.sql_subscript(1)).must_equal "abc.def[1]"
+  end
+
   it "should support cast_numeric and cast_string" do
     x = :abc.cast_numeric
     x.must_be_kind_of(Sequel::SQL::NumericExpression)
@@ -726,3 +743,90 @@ describe "symbol_aref extensions" do
     end
   end
 end
+
+describe Sequel::SQL::VirtualRow do
+  before do
+    @d = Sequel.mock[:items].with_quote_identifiers(true).with_extend do
+      def supports_window_functions?; true end
+      def l(*args, &block)
+        literal(filter_expr(*args, &block))
+      end
+    end
+  end
+
+  it "should treat methods without blocks normally" do
+    @d.l{column}.must_equal '"column"'
+    @d.l{foo(a)}.must_equal 'foo("a")'
+  end
+
+
+  it "should treat methods with a block and no arguments as a function call with no arguments" do
+    @d.l{version{}}.must_equal 'version()'
+  end
+
+  it "should treat methods with a block and a leading argument :* as a function call with the SQL wildcard" do
+    @d.l{count(:*){}}.must_equal 'count(*)'
+  end
+
+  it "should treat methods with a block and a leading argument :distinct as a function call with DISTINCT and the additional method arguments" do
+    @d.l{count(:distinct, column1){}}.must_equal 'count(DISTINCT "column1")'
+    @d.l{count(:distinct, column1, column2){}}.must_equal 'count(DISTINCT "column1", "column2")'
+  end
+
+  it "should raise an error if an unsupported argument is used with a block" do
+    proc{@d.where{count(:blah){}}}.must_raise(Sequel::Error)
+  end
+
+  it "should treat methods with a block and a leading argument :over as a window function call" do
+    @d.l{rank(:over){}}.must_equal 'rank() OVER ()'
+  end
+
+  it "should support :partition options for window function calls" do
+    @d.l{rank(:over, :partition=>column1){}}.must_equal 'rank() OVER (PARTITION BY "column1")'
+    @d.l{rank(:over, :partition=>[column1, column2]){}}.must_equal 'rank() OVER (PARTITION BY "column1", "column2")'
+  end
+
+  it "should support :args options for window function calls" do
+    @d.l{avg(:over, :args=>column1){}}.must_equal 'avg("column1") OVER ()'
+    @d.l{avg(:over, :args=>[column1, column2]){}}.must_equal 'avg("column1", "column2") OVER ()'
+  end
+
+  it "should support :order option for window function calls" do
+    @d.l{rank(:over, :order=>column1){}}.must_equal 'rank() OVER (ORDER BY "column1")'
+    @d.l{rank(:over, :order=>[column1, column2]){}}.must_equal 'rank() OVER (ORDER BY "column1", "column2")'
+  end
+
+  it "should support :window option for window function calls" do
+    @d.l{rank(:over, :window=>:win){}}.must_equal 'rank() OVER ("win")'
+  end
+
+  it "should support :*=>true option for window function calls" do
+    @d.l{count(:over, :* =>true){}}.must_equal 'count(*) OVER ()'
+  end
+
+  it "should support :frame=>:all option for window function calls" do
+    @d.l{rank(:over, :frame=>:all){}}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)'
+  end
+
+  it "should support :frame=>:rows option for window function calls" do
+    @d.l{rank(:over, :frame=>:rows){}}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
+  end
+
+  it "should support :frame=>'some string' option for window function calls" do
+    @d.l{rank(:over, :frame=>'RANGE BETWEEN 3 PRECEDING AND CURRENT ROW'){}}.must_equal 'rank() OVER (RANGE BETWEEN 3 PRECEDING AND CURRENT ROW)'
+  end
+
+  it "should raise an error if an invalid :frame option is used" do
+    proc{@d.l{rank(:over, :frame=>:blah){}}}.must_raise(Sequel::Error)
+  end
+
+  it "should support all these options together" do
+    @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.must_equal 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
+  end
+
+  it "should raise an error if window functions are not supported" do
+    proc{@d.with_extend{def supports_window_functions?; false end}.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}}.must_raise(Sequel::Error)
+    proc{Sequel.mock.dataset.filter{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.sql}.must_raise(Sequel::Error)
+  end
+end
+

data/spec/deprecation_helper.rb

@@ -1,8 +1,8 @@
 Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_spec\.rb/}
 
 class Minitest::HooksSpec
-  def self.deprecated(*a, &block)
-    it(*a) do
+  def self.deprecated(a, &block)
+    it("#{a} (deprecated)") do
       deprecated{instance_exec(&block)}
     end
   end
@@ -14,4 +14,29 @@ class Minitest::HooksSpec
   ensure
     Sequel::Deprecation.output = output
   end
+
+  def self.with_symbol_splitting(a, &block)
+    it(a) do
+      with_symbol_splitting{instance_exec(&block)}
+    end
+    it("#{a}, except when symbol_splitting disabled") do
+      without_symbol_splitting{instance_exec(&block)}
+    end
+  end
+
+  def without_symbol_splitting
+    Sequel.split_symbols = false
+    DB.send(:reset_default_dataset) if defined?(DB)
+    proc{yield}.must_raise Minitest::Assertion
+  ensure
+    Sequel.split_symbols = :deprecated
+    DB.send(:reset_default_dataset) if defined?(DB)
+  end
+
+  def with_symbol_splitting
+    Sequel.split_symbols = true
+    yield
+  ensure
+    Sequel.split_symbols = :deprecated
+  end
 end