sequel 4.44.0 → 4.45.0

data/spec/core/dataset_mutation_spec.rb

@@ -8,42 +8,42 @@ describe "Dataset" do
     @d = Sequel.mock.dataset.from(:x)
   end
 
-  it "should support self-changing select!" do
+  deprecated "should support self-changing select!" do
     @d.select!(:y)
     @d.sql.must_equal "SELECT y FROM x"
   end
   
-  it "should support self-changing from!" do
+  deprecated "should support self-changing from!" do
     @d.from!(:y)
     @d.sql.must_equal "SELECT * FROM y"
   end
 
-  it "should support self-changing order!" do
+  deprecated "should support self-changing order!" do
     @d.order!(:y)
     @d.sql.must_equal "SELECT * FROM x ORDER BY y"
   end
   
-  it "should support self-changing filter!" do
+  deprecated "should support self-changing filter!" do
     @d.filter!(:y => 1)
     @d.sql.must_equal "SELECT * FROM x WHERE (y = 1)"
   end
 
-  it "should support self-changing filter! with block" do
+  deprecated "should support self-changing filter! with block" do
     @d.filter!{y < 2}
     @d.sql.must_equal "SELECT * FROM x WHERE (y < 2)"
   end
   
-  it "should raise for ! methods that don't return a dataset" do
+  deprecated "should raise for ! methods that don't return a dataset" do
     proc {@d.opts!}.must_raise(NoMethodError)
   end
   
-  it "should raise for missing methods" do
+  deprecated "should raise for missing methods" do
     proc {@d.xuyz}.must_raise(NoMethodError)
     proc {@d.xyz!}.must_raise(NoMethodError)
     proc {@d.xyz?}.must_raise(NoMethodError)
   end
   
-  it "should support chaining of bang methods" do
+  deprecated "should support chaining of bang methods" do
       @d.order!(:y).filter!(:y => 1).sql.must_equal "SELECT * FROM x WHERE (y = 1) ORDER BY y"
   end
 end
@@ -53,11 +53,11 @@ describe "Frozen Datasets" do
     @ds = Sequel.mock[:test].freeze
   end
 
-  it "should have dups not be frozen" do
+  deprecated "should have dups not be frozen" do
     @ds.dup.wont_be :frozen?
   end
 
-  it "should raise an error when calling mutation methods" do
+  deprecated "should raise an error when calling mutation methods" do
     proc{@ds.select!(:a)}.must_raise RuntimeError
     proc{@ds.row_proc = proc{}}.must_raise RuntimeError
     proc{@ds.extension! :query}.must_raise RuntimeError
@@ -74,7 +74,7 @@ describe "Dataset mutation methods" do
     ds.sql
   end
 
-  it "should modify the dataset in place" do
+  deprecated "should modify the dataset in place" do
     dsc = Sequel.mock[:u]
     dsc.send(:columns=, [:v])
 
@@ -132,7 +132,7 @@ describe "Dataset mutation methods" do
     dsc.graph!(dsc, {:b=>:c}, :table_alias=>:foo).ungraphed!.opts[:graph].must_be_nil
   end
 
-  it "should clear the cache" do
+  deprecated "should clear the cache" do
     ds = Sequel.mock[:a]
     ds.columns
     ds.send(:cache_set, :columns, [:a])
@@ -145,7 +145,7 @@ describe "Dataset#clone" do
     @dataset = Sequel.mock.dataset.from(:items)
   end
 
-  it "should copy the dataset opts" do
+  deprecated "should copy the dataset opts" do
     clone = @dataset.clone
     clone.opts.must_equal @dataset.opts
     @dataset.filter!(:a => 'b')
@@ -173,20 +173,20 @@ describe "Dataset extensions" do
     @ds = Sequel.mock.dataset
   end
 
-  it "should have #extension! modify the receiver" do
+  deprecated "should have #extension! modify the receiver" do
     Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
     @ds.extension!(:foo)
     @ds.a.must_equal 1
   end
 
-  it "should have #extension! return the receiver" do
+  deprecated "should have #extension! return the receiver" do
     Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
     @ds.extension!(:foo).must_be_same_as(@ds)
   end
 end
 
 describe "Dataset#naked!" do
-  it "should remove any existing row_proc" do
+  deprecated "should remove any existing row_proc" do
     d = Sequel.mock.dataset.with_row_proc(Proc.new{|r| r})
     d.naked!.row_proc.must_be_nil
     d.row_proc.must_be_nil
@@ -194,7 +194,7 @@ describe "Dataset#naked!" do
 end
 
 describe "Dataset#row_proc=" do
-  it "should set the row_proc" do
+  deprecated "should set the row_proc" do
     d = Sequel.mock.dataset.with_row_proc(Proc.new{|r| r})
     d.row_proc.wont_be_nil
     d.row_proc = nil
@@ -203,7 +203,7 @@ describe "Dataset#row_proc=" do
 end
 
 describe "Dataset#quote_identifiers=" do
-  it "should change quote identifiers setting" do
+  deprecated "should change quote identifiers setting" do
     d = Sequel.mock.dataset.with_quote_identifiers(true)
     d.literal(:a).must_equal '"a"'
     d.quote_identifiers = false
@@ -212,13 +212,13 @@ describe "Dataset#quote_identifiers=" do
 end
 
 describe "Dataset#from_self!" do
-  it "should work" do
+  deprecated "should work" do
     Sequel.mock.dataset.from(:test).select(:name).limit(1).from_self!.sql.must_equal 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS t1'
   end
 end
 
 describe "Sequel Mock Adapter" do
-  it "should be able to set the rows returned by each on a per dataset basis using _fetch" do
+  deprecated "should be able to set the rows returned by each on a per dataset basis using _fetch" do
     rs = []
     db = Sequel.mock(:fetch=>{:a=>1})
     ds = db[:t]
@@ -229,7 +229,7 @@ describe "Sequel Mock Adapter" do
     rs.must_equal [{:a=>1}, {:b=>2}]
   end
 
-  it "should be able to set the number of rows modified by update and delete on a per dataset basis" do
+  deprecated "should be able to set the number of rows modified by update and delete on a per dataset basis" do
     db = Sequel.mock(:numrows=>2)
     ds = db[:t]
     ds.update(:a=>1).must_equal 2
@@ -239,7 +239,7 @@ describe "Sequel Mock Adapter" do
     ds.delete.must_equal 3
   end
 
-  it "should be able to set the autogenerated primary key returned by insert on a per dataset basis" do
+  deprecated "should be able to set the autogenerated primary key returned by insert on a per dataset basis" do
     db = Sequel.mock(:autoid=>1)
     ds = db[:t]
     ds.insert(:a=>1).must_equal 1

data/spec/core/dataset_spec.rb

@@ -233,6 +233,68 @@ describe "A dataset with multiple tables in its FROM clause" do
   end
 end
 
+describe "A dataset with a limit" do
+  before do
+    @dataset = Sequel.mock[:a].limit(1)
+  end
+
+  it "should ignore limit if skip_limit_check is used before #update" do
+    @dataset.skip_limit_check.update(:a=>1)
+    @dataset.db.sqls.must_equal ['UPDATE a SET a = 1']
+  end
+
+  it "should ignore limit if skip_limit_check is used before #delete" do
+    @dataset.skip_limit_check.delete
+    @dataset.db.sqls.must_equal ['DELETE FROM a']
+  end
+  
+  if false #SEQUEL5
+    it "should raise on #update" do
+      proc{@dataset.update(:a=>1)}.must_raise(Sequel::InvalidOperation)
+    end
+
+    it "should raise on #delete" do
+      proc{@dataset.delete}.must_raise(Sequel::InvalidOperation)
+    end
+    
+    it "should raise on #truncate" do
+      proc{@dataset.truncate}.must_raise(Sequel::InvalidOperation)
+      proc{@dataset.skip_limit_check.truncate}.must_raise(Sequel::InvalidOperation)
+    end
+  end
+end
+
+describe "A dataset with an offset" do
+  before do
+    @dataset = Sequel.mock[:a].offset(1)
+  end
+
+  it "should ignore offset if skip_limit_check is used before #update" do
+    @dataset.skip_limit_check.update(:a=>1)
+    @dataset.db.sqls.must_equal ['UPDATE a SET a = 1']
+  end
+
+  it "should ignore offset if skip_limit_check is used before #delete" do
+    @dataset.skip_limit_check.delete
+    @dataset.db.sqls.must_equal ['DELETE FROM a']
+  end
+  
+  if false #SEQUEL5
+    it "should raise on #update" do
+      proc{@dataset.update(:a=>1)}.must_raise(Sequel::InvalidOperation)
+    end
+
+    it "should raise on #delete" do
+      proc{@dataset.delete}.must_raise(Sequel::InvalidOperation)
+    end
+    
+    it "should raise on #truncate" do
+      proc{@dataset.truncate}.must_raise(Sequel::InvalidOperation)
+      proc{@dataset.skip_limit_check.truncate}.must_raise(Sequel::InvalidOperation)
+    end
+  end
+end
+
 describe "Dataset#unused_table_alias" do
   before do
     @ds = Sequel.mock.dataset.from(:test)
@@ -498,7 +560,7 @@ describe "Dataset#where" do
     @dataset.filter(Sequel::SQLFALSE).sql.must_equal "SELECT * FROM test WHERE (1 = 0)"
   end
 
-  it "should allow the use of multiple arguments" do
+  deprecated "should allow the use of multiple arguments" do
     @dataset.filter(:a, :b).sql.must_equal 'SELECT * FROM test WHERE (a AND b)'
     @dataset.filter(:a, :b=>1).sql.must_equal 'SELECT * FROM test WHERE (a AND (b = 1))'
     @dataset.filter(:a, Sequel.expr(:c) > 3, :b=>1).sql.must_equal 'SELECT * FROM test WHERE (a AND (c > 3) AND (b = 1))'
@@ -508,6 +570,10 @@ describe "Dataset#where" do
     @dataset.filter(Sequel.expr(:zz) < 3){yy > 3}.sql.must_equal 'SELECT * FROM test WHERE ((zz < 3) AND (yy > 3))'
   end
 
+  deprecated "should allow the use of procs" do
+    @dataset.filter(proc{yy > 3}).sql.must_equal 'SELECT * FROM test WHERE (yy > 3)'
+  end
+
   it "should yield a VirtualRow to the block" do
     x = nil
     @dataset.filter{|r| x = r; false}
@@ -3648,7 +3714,7 @@ describe "Dataset prepared statements and bound variables " do
     @db.sqls.must_equal ["SELECT * FROM items"]
   end
 
-  it "#call should default to using :all if an invalid type is given" do
+  deprecated "#call should default to using :all if an invalid type is given" do
     @ds.filter(:num=>:$n).call(:select_all, :n=>1)
     @db.sqls.must_equal ['SELECT * FROM items WHERE (num = 1)']
   end
@@ -3698,7 +3764,7 @@ describe "Dataset prepared statements and bound variables " do
   it "should handle usage with Dataset.prepared_statements_module" do
     @ds = @ds.with_extend(Sequel::Dataset.send(:prepared_statements_module, :prepare_bind, [Sequel::Dataset::ArgumentMapper, Sequel::Dataset::PreparedStatementMethods]){def foo; :bar; end})
     @ds.foo.must_equal :bar
-    @ds = @ds.clone(:prepared_statement_name => 'foo')
+    @ds = @ds.clone(:prepared_statement_name => 'foo', :prepared_type=>:select)
     @ds.call(:a=>1)
     @db.sqls.must_equal ["foo"]
   end
@@ -3749,7 +3815,7 @@ describe Sequel::Dataset::UnnumberedArgumentMapper do
       "UPDATE items SET num = ? WHERE (num = ?) -- args: [1, 1]"]
   end
 
-  it "should handle unrecognized statement types as :all" do
+  deprecated "should handle unrecognized statement types as :all" do
     ps = @ds.prepare(:select_all, :s)
     ps = ps.with_extend(Sequel::Dataset::UnnumberedArgumentMapper)
     sql = ps.prepared_sql
@@ -3900,11 +3966,13 @@ end
 
 describe "Sequel::Dataset#unbind" do
   before do
-    @ds = Sequel.mock[:t]
-    @u = proc{|ds| ds, bv = ds.unbind; [ds.sql, bv]}
+    deprecated do
+      @ds = Sequel.mock[:t]
+      @u = proc{|ds| ds, bv = ds.unbind; [ds.sql, bv]}
+    end
   end
 
-  it "should unbind values assigned to equality and inequality statements" do
+  deprecated "should unbind values assigned to equality and inequality statements" do
     @ds.filter(:foo=>1).unbind.first.sql.must_equal "SELECT * FROM t WHERE (foo = $foo)"
     @ds.exclude(:foo=>1).unbind.first.sql.must_equal "SELECT * FROM t WHERE (foo != $foo)"
     @ds.filter{foo > 1}.unbind.first.sql.must_equal "SELECT * FROM t WHERE (foo > $foo)"
@@ -3913,17 +3981,17 @@ describe "Sequel::Dataset#unbind" do
     @ds.filter{foo <= 1}.unbind.first.sql.must_equal "SELECT * FROM t WHERE (foo <= $foo)"
   end
 
-  it "should return variables that could be used bound to recreate the previous query" do
+  deprecated "should return variables that could be used bound to recreate the previous query" do
     @ds.filter(:foo=>1).unbind.last.must_equal(:foo=>1)
     @ds.exclude(:foo=>1).unbind.last.must_equal(:foo=>1)
   end
 
-  it "should return variables as symbols" do
+  deprecated "should return variables as symbols" do
     @ds.filter(Sequel.expr(:foo)=>1).unbind.last.must_equal(:foo=>1)
     @ds.exclude(Sequel.expr(:foo__bar)=>1).unbind.last.must_equal(:"foo.bar"=>1)
   end
 
-  it "should handle numerics, strings, dates, times, and datetimes" do
+  deprecated "should handle numerics, strings, dates, times, and datetimes" do
     @u[@ds.filter(:foo=>1)].must_equal ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>1}]
     @u[@ds.filter(:foo=>1.0)].must_equal ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>1.0}]
     @u[@ds.filter(:foo=>BigDecimal.new('1.0'))].must_equal ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>BigDecimal.new('1.0')}]
@@ -3935,43 +4003,43 @@ describe "Sequel::Dataset#unbind" do
     @u[@ds.filter(:foo=>dt)].must_equal ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>dt}]
   end
 
-  it "should not unbind literal strings" do
+  deprecated "should not unbind literal strings" do
     @u[@ds.filter(:foo=>Sequel.lit('a'))].must_equal ["SELECT * FROM t WHERE (foo = a)", {}]
   end
 
-  it "should not unbind Identifiers, QualifiedIdentifiers, or Symbols used as booleans" do
+  deprecated "should not unbind Identifiers, QualifiedIdentifiers, or Symbols used as booleans" do
     @u[@ds.filter(:foo).filter{bar}.filter{foo__bar}].must_equal ["SELECT * FROM t WHERE (foo AND bar AND foo.bar)", {}]
   end
 
-  it "should not unbind for values it doesn't understand" do
+  deprecated "should not unbind for values it doesn't understand" do
     @u[@ds.filter(:foo=>Class.new{def sql_literal(ds) 'bar' end}.new)].must_equal ["SELECT * FROM t WHERE (foo = bar)", {}]
   end
 
-  it "should handle QualifiedIdentifiers" do
+  deprecated "should handle QualifiedIdentifiers" do
     @u[@ds.filter{foo__bar > 1}].must_equal ["SELECT * FROM t WHERE (foo.bar > $foo.bar)", {:"foo.bar"=>1}]
   end
 
-  it "should handle wrapped objects" do
+  deprecated "should handle wrapped objects" do
     @u[@ds.filter{Sequel::SQL::Wrapper.new(foo__bar) > Sequel::SQL::Wrapper.new(1)}].must_equal ["SELECT * FROM t WHERE (foo.bar > $foo.bar)", {:"foo.bar"=>1}]
   end
 
-  it "should handle deep nesting" do
+  deprecated "should handle deep nesting" do
     @u[@ds.filter{foo > 1}.and{bar < 2}.or(:baz=>3).and(Sequel.case({~Sequel.expr(:x=>4)=>true}, false))].must_equal ["SELECT * FROM t WHERE ((((foo > $foo) AND (bar < $bar)) OR (baz = $baz)) AND (CASE WHEN (x != $x) THEN 't' ELSE 'f' END))", {:foo=>1, :bar=>2, :baz=>3, :x=>4}]
   end
 
-  it "should handle JOIN ON" do
+  deprecated "should handle JOIN ON" do
     @u[@ds.cross_join(:x).join(:a, [:u]).join(:b, [[:c, :d], [:e,1]])].must_equal ["SELECT * FROM t CROSS JOIN x INNER JOIN a USING (u) INNER JOIN b ON ((b.c = a.d) AND (b.e = $b.e))", {:"b.e"=>1}]
   end
 
-  it "should raise an UnbindDuplicate exception if same variable is used with multiple different values" do
+  deprecated "should raise an UnbindDuplicate exception if same variable is used with multiple different values" do
     proc{@ds.filter(:foo=>1).or(:foo=>2).unbind}.must_raise(Sequel::UnbindDuplicate)
   end
 
-  it "should handle case where the same variable has the same value in multiple places " do
+  deprecated "should handle case where the same variable has the same value in multiple places " do
     @u[@ds.filter(:foo=>1).or(:foo=>1)].must_equal ["SELECT * FROM t WHERE ((foo = $foo) OR (foo = $foo))", {:foo=>1}]
   end
 
-  it "should raise Error for unhandled objects inside Identifiers and QualifiedIndentifiers" do
+  deprecated "should raise Error for unhandled objects inside Identifiers and QualifiedIndentifiers" do
     proc{@ds.filter(Sequel::SQL::Identifier.new([]) > 1).unbind}.must_raise(Sequel::Error)
     proc{@ds.filter{foo.qualify({}) > 1}.unbind}.must_raise(Sequel::Error)
   end

data/spec/core/deprecated_spec.rb

@@ -27,7 +27,7 @@ describe "Sequel::Deprecated" do
 
   it "should consider two arguments to be a method name and additional text" do
     @d.deprecate("foo", "Use bar instead")
-    @output.must_equal ['foo is deprecated and will be removed in a future version of Sequel.  Use bar instead.']
+    @output.must_equal ['foo is deprecated and will be removed in Sequel 5.  Use bar instead.']
   end
 
   it "should include a prefix if set" do

data/spec/core/expression_filters_spec.rb

@@ -653,7 +653,7 @@ describe Sequel::SQL::VirtualRow do
   end
 
   it "should handle filtered aggregate function calls" do
-    @d.l{count{}.*.filter(:a, :b)}.must_equal 'count(*) FILTER (WHERE ("a" AND "b"))' 
+    @d.l{count{}.*.filter(Sequel.&(:a, :b))}.must_equal 'count(*) FILTER (WHERE ("a" AND "b"))' 
     @d.l{count{}.*.filter(:a=>1)}.must_equal 'count(*) FILTER (WHERE ("a" = 1))'
     @d.l{count{}.*.filter{b > 1}}.must_equal 'count(*) FILTER (WHERE ("b" > 1))'
     @d.l{count{}.*.filter(:a=>1){b > 1}}.must_equal 'count(*) FILTER (WHERE (("a" = 1) AND ("b" > 1)))'

data/spec/core/mock_adapter_spec.rb

@@ -450,10 +450,7 @@ describe "Sequel Mock Adapter" do
 
   it "should be able to load dialects based on the database name" do
     Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.must_equal 'SELECT #2011-12-13#'
-    Sequel.mock(:host=>'cubrid').from(:a).offset(1).with_quote_identifiers(false).sql.must_equal 'SELECT * FROM a LIMIT 1,4294967295'
     Sequel.mock(:host=>'db2').select(1).sql.must_equal 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
-    Sequel.mock(:host=>'firebird')[:A].distinct.limit(1, 2).with_quote_identifiers(false).sql.must_equal 'SELECT DISTINCT FIRST 1 SKIP 2 * FROM A'
-    Sequel.mock(:host=>'informix')[:a].distinct.limit(1, 2).sql.upcase.must_equal 'SELECT SKIP 2 FIRST 1 DISTINCT * FROM A'
     Sequel.mock(:host=>'mssql', :identifier_mangling=>false)[:A].full_text_search(:B, 'C').with_quote_identifiers(false).sql.must_equal "SELECT * FROM A WHERE (CONTAINS (B, 'C'))"
     Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').with_quote_identifiers(false).sql.must_equal "SELECT * FROM a WHERE (MATCH (b) AGAINST ('c'))"
     Sequel.mock(:host=>'oracle')[:a].limit(1).with_quote_identifiers(false).sql.upcase.must_equal 'SELECT * FROM (SELECT * FROM A) T1 WHERE (ROWNUM <= 1)'

data/spec/core/placeholder_literalizer_spec.rb

@@ -52,7 +52,7 @@ describe "Dataset::PlaceholderLiteralizer" do
   it "should handle calls with a placeholders used as filter arguments" do
     loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
     loader.first(:id=>1).must_equal @h
-    loader.first(proc{a(b)}).must_equal @h
+    loader.first(Sequel.expr{a(b)}).must_equal @h
     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)"]
   end

data/spec/core/schema_spec.rb

@@ -598,13 +598,20 @@ describe "DB#create_table" do
     @db.sqls.must_equal ["CREATE TABLE cats (CHECK (price = 100))"]
   end
 
-  it "should accept array constraints" do
+  deprecated "should accept array constraints" do
     @db.create_table(:cats) do
       check [Sequel.expr(:x) > 0, Sequel.expr(:y) < 1]
     end
     @db.sqls.must_equal ["CREATE TABLE cats (CHECK ((x > 0) AND (y < 1)))"]
   end
 
+  it "should accept expression constraints" do
+    @db.create_table(:cats) do
+      check Sequel.&(Sequel.expr(:x) > 0, Sequel.expr(:y) < 1)
+    end
+    @db.sqls.must_equal ["CREATE TABLE cats (CHECK ((x > 0) AND (y < 1)))"]
+  end
+
   it "should accept named constraint definitions" do
     @db.create_table(:cats) do
       integer :score

data/spec/core/spec_helper.rb

@@ -10,13 +10,14 @@ unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
   require 'sequel/core'
 end
-Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_spec\.rb/}
 
 gem 'minitest'
 require 'minitest/autorun'
 require 'minitest/hooks/default'
 require 'minitest/shared_description'
 
+require "#{File.dirname(File.dirname(__FILE__))}/deprecation_helper.rb"
+
 class Minitest::HooksSpec
   def meta_def(obj, name, &block)
     (class << obj; self end).send(:define_method, name, &block)
@@ -30,6 +31,10 @@ if ENV['SEQUEL_COLUMNS_INTROSPECTION']
   Sequel::Mock::Dataset.send(:include, Sequel::ColumnsIntrospection)
 end
 
+# SEQUEL5: Remove
+output = Sequel::Deprecation.output
+Sequel::Deprecation.output = nil
 Sequel.quote_identifiers = false
 Sequel.identifier_input_method = nil
 Sequel.identifier_output_method = nil
+Sequel::Deprecation.output = output