sequel 5.8.0 → 5.9.0

data/spec/extensions/escaped_like_spec.rb

@@ -0,0 +1,40 @@
+require_relative "spec_helper"
+
+describe "escaped_like extension" do
+  before do
+    Sequel.extension(:escaped_like)
+    @ds = Sequel.mock[:t]
+    @c = Sequel[:c]
+  end
+
+  it "escaped_like should support creating case sensitive pattern matches" do
+    @ds.where(@c.escaped_like('?', 'a')).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a' ESCAPE '\\')"
+    @ds.where(@c.escaped_like('?%', 'a')).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a%' ESCAPE '\\')"
+    @ds.where(@c.escaped_like('?', 'a%')).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a\\%' ESCAPE '\\')"
+    @ds.where(@c.escaped_like('?', ['a%'])).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a\\%' ESCAPE '\\')"
+    @ds.where(@c.escaped_like('??', ['a', '%'])).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a\\%' ESCAPE '\\')"
+  end
+
+  it "escaped_ilike should support creating case insensitive pattern matches" do
+    @ds.where(@c.escaped_ilike('?', 'a')).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a') ESCAPE '\\')"
+    @ds.where(@c.escaped_ilike('?%', 'a')).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a%') ESCAPE '\\')"
+    @ds.where(@c.escaped_ilike('?', 'a%')).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a\\%') ESCAPE '\\')"
+    @ds.where(@c.escaped_ilike('?', ['a%'])).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a\\%') ESCAPE '\\')"
+    @ds.where(@c.escaped_ilike('??', ['a', '%'])).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a\\%') ESCAPE '\\')"
+  end
+
+  it "should raise an Error for a mismatched number of placeholders" do
+    proc{@ds.where(@c.escaped_like('?', [])).sql}.must_raise Sequel::Error
+    proc{@ds.where(@c.escaped_like('??', ['a'])).sql}.must_raise Sequel::Error
+    proc{@ds.where(@c.escaped_ilike('', ['a'])).sql}.must_raise Sequel::Error
+    proc{@ds.where(@c.escaped_ilike('?', ['a', 'a'])).sql}.must_raise Sequel::Error
+  end
+
+  it "escaped_like and escaped_ilike should return expressions" do
+    @ds.select(@c.escaped_like('?', 'a').as(:b)).sql.must_equal "SELECT (c LIKE 'a' ESCAPE '\\') AS b FROM t"
+    @ds.select(@c.escaped_like('?', 'a').cast(String)).sql.must_equal "SELECT CAST((c LIKE 'a' ESCAPE '\\') AS varchar(255)) FROM t"
+    @ds.order(@c.escaped_like('?', 'a').desc).sql.must_equal "SELECT * FROM t ORDER BY (c LIKE 'a' ESCAPE '\\') DESC"
+    @ds.where(@c.escaped_like('?', 'a') | @c.escaped_like('?', 'b')).sql.must_equal "SELECT * FROM t WHERE ((c LIKE 'a' ESCAPE '\\') OR (c LIKE 'b' ESCAPE '\\'))"
+  end
+end
+

data/spec/extensions/eval_inspect_spec.rb

@@ -62,7 +62,7 @@ describe "eval_inspect extension" do
       Sequel::SQL::AliasedExpression.new(Time.local(2011, 9, 11, 10, 20, 30, 500000.125), :a),
       Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30), :a),
       Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30, 500000.125), :a),
-      Sequel::SQL::AliasedExpression.new(BigDecimal.new('1.000000000000000000000000000000000000000000000001'), :a),
+      Sequel::SQL::AliasedExpression.new(BigDecimal('1.000000000000000000000000000000000000000000000001'), :a),
       Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_DATE, :a),
       Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_TIMESTAMP, :a),
     ].each do |o|

data/spec/extensions/nested_attributes_spec.rb

@@ -49,6 +49,12 @@ describe "NestedAttributes plugin" do
     @db.sqls
   end
   
+  it "should not modify options hash when loading plugin" do
+    h = {}
+    @Concert.nested_attributes :albums, h
+    h.must_equal({})
+  end
+  
   it "should support creating new many_to_one objects" do
     a = @Album.new({:name=>'Al', :artist_attributes=>{:name=>'Ar'}})
     @db.sqls.must_equal []

data/spec/extensions/pg_array_spec.rb

@@ -92,30 +92,30 @@ describe "pg_array extension" do
   it "should parse single dimensional decimal arrays" do
     c = @converter[1231]
     c.call("{}").to_a.must_equal []
-    c.call("{1.5}").to_a.must_equal [BigDecimal.new('1.5')]
-    c.call('{2.5,3.5}').to_a.must_equal [BigDecimal.new('2.5'), BigDecimal.new('3.5')]
-    c.call('{3.5,4.5,5.5}').to_a.must_equal [BigDecimal.new('3.5'), BigDecimal.new('4.5'), BigDecimal.new('5.5')]
+    c.call("{1.5}").to_a.must_equal [BigDecimal('1.5')]
+    c.call('{2.5,3.5}').to_a.must_equal [BigDecimal('2.5'), BigDecimal('3.5')]
+    c.call('{3.5,4.5,5.5}').to_a.must_equal [BigDecimal('3.5'), BigDecimal('4.5'), BigDecimal('5.5')]
   end
 
   it "should parse multiple dimensional decimal arrays" do
     c = @converter[1231]
     c.call("{{}}").to_a.must_equal [[]]
-    c.call("{{1.5}}").to_a.must_equal [[BigDecimal.new('1.5')]]
-    c.call('{{2.5},{3.5}}').to_a.must_equal [[BigDecimal.new('2.5')], [BigDecimal.new('3.5')]]
-    c.call('{{{1.5,2.5},{3.5,4.5}},{{5.5,6.5},{7.5,8.5}}}').to_a.must_equal [[[BigDecimal.new('1.5'), BigDecimal.new('2.5')], [BigDecimal.new('3.5'), BigDecimal.new('4.5')]], [[BigDecimal.new('5.5'), BigDecimal.new('6.5')], [BigDecimal.new('7.5'), BigDecimal.new('8.5')]]]
+    c.call("{{1.5}}").to_a.must_equal [[BigDecimal('1.5')]]
+    c.call('{{2.5},{3.5}}').to_a.must_equal [[BigDecimal('2.5')], [BigDecimal('3.5')]]
+    c.call('{{{1.5,2.5},{3.5,4.5}},{{5.5,6.5},{7.5,8.5}}}').to_a.must_equal [[[BigDecimal('1.5'), BigDecimal('2.5')], [BigDecimal('3.5'), BigDecimal('4.5')]], [[BigDecimal('5.5'), BigDecimal('6.5')], [BigDecimal('7.5'), BigDecimal('8.5')]]]
   end
 
   it "should parse decimal values with arbitrary precision" do
     c = @converter[1231]
-    c.call("{1.000000000000000000005}").to_a.must_equal [BigDecimal.new('1.000000000000000000005')]
-    c.call("{{1.000000000000000000005,2.000000000000000000005},{3.000000000000000000005,4.000000000000000000005}}").to_a.must_equal [[BigDecimal.new('1.000000000000000000005'), BigDecimal.new('2.000000000000000000005')], [BigDecimal.new('3.000000000000000000005'), BigDecimal.new('4.000000000000000000005')]]
+    c.call("{1.000000000000000000005}").to_a.must_equal [BigDecimal('1.000000000000000000005')]
+    c.call("{{1.000000000000000000005,2.000000000000000000005},{3.000000000000000000005,4.000000000000000000005}}").to_a.must_equal [[BigDecimal('1.000000000000000000005'), BigDecimal('2.000000000000000000005')], [BigDecimal('3.000000000000000000005'), BigDecimal('4.000000000000000000005')]]
   end
 
   it "should parse integers in decimal arrays as BigDecimals" do
     c = @converter[1231]
     c.call("{1}").to_a.first.must_be_kind_of(BigDecimal)
-    c.call("{1}").to_a.must_equal [BigDecimal.new('1')]
-    c.call('{{{1,2},{3,4}},{{5,6},{7,8}}}').to_a.must_equal [[[BigDecimal.new('1'), BigDecimal.new('2')], [BigDecimal.new('3'), BigDecimal.new('4')]], [[BigDecimal.new('5'), BigDecimal.new('6')], [BigDecimal.new('7'), BigDecimal.new('8')]]]
+    c.call("{1}").to_a.must_equal [BigDecimal('1')]
+    c.call('{{{1,2},{3,4}},{{5,6},{7,8}}}').to_a.must_equal [[[BigDecimal('1'), BigDecimal('2')], [BigDecimal('3'), BigDecimal('4')]], [[BigDecimal('5'), BigDecimal('6')], [BigDecimal('7'), BigDecimal('8')]]]
   end
 
   it "should parse arrays with NULL values" do
@@ -149,7 +149,7 @@ describe "pg_array extension" do
     @db.literal(@m::PGArray.new([nil])).must_equal 'ARRAY[NULL]'
     @db.literal(@m::PGArray.new([nil, 1])).must_equal 'ARRAY[NULL,1]'
     @db.literal(@m::PGArray.new([1.0, 2.5])).must_equal 'ARRAY[1.0,2.5]'
-    @db.literal(@m::PGArray.new([BigDecimal.new('1'), BigDecimal.new('2.000000000000000000005')])).must_equal 'ARRAY[1.0,2.000000000000000000005]'
+    @db.literal(@m::PGArray.new([BigDecimal('1'), BigDecimal('2.000000000000000000005')])).must_equal 'ARRAY[1.0,2.000000000000000000005]'
     @db.literal(@m::PGArray.new([nil, "NULL"])).must_equal "ARRAY[NULL,'NULL']"
     @db.literal(@m::PGArray.new([nil, "{},[]'\""])).must_equal "ARRAY[NULL,'{},[]''\"']"
   end
@@ -169,7 +169,7 @@ describe "pg_array extension" do
     @db.literal(@m::PGArray.new([nil], :text)).must_equal 'ARRAY[NULL]::text[]'
     @db.literal(@m::PGArray.new([nil, 1], :int8)).must_equal 'ARRAY[NULL,1]::int8[]'
     @db.literal(@m::PGArray.new([1.0, 2.5], :real)).must_equal 'ARRAY[1.0,2.5]::real[]'
-    @db.literal(@m::PGArray.new([BigDecimal.new('1'), BigDecimal.new('2.000000000000000000005')], :decimal)).must_equal 'ARRAY[1.0,2.000000000000000000005]::decimal[]'
+    @db.literal(@m::PGArray.new([BigDecimal('1'), BigDecimal('2.000000000000000000005')], :decimal)).must_equal 'ARRAY[1.0,2.000000000000000000005]::decimal[]'
     @db.literal(@m::PGArray.new([nil, "NULL"], :varchar)).must_equal "ARRAY[NULL,'NULL']::varchar[]"
     @db.literal(@m::PGArray.new([nil, "{},[]'\""], :"varchar(255)")).must_equal "ARRAY[NULL,'{},[]''\"']::varchar(255)[]"
   end
@@ -224,7 +224,7 @@ describe "pg_array extension" do
     {
       :integer=>{:class=>Integer, :convert=>['1', 1, '1']},
       :float=>{:db_type=>'double precision',  :class=>Float, :convert=>['1.1', 1.1, '1.1']},
-      :decimal=>{:db_type=>'numeric', :class=>BigDecimal, :convert=>['1.00000000000000000000000001', BigDecimal.new('1.00000000000000000000000001'), '1.00000000000000000000000001']},
+      :decimal=>{:db_type=>'numeric', :class=>BigDecimal, :convert=>['1.00000000000000000000000001', BigDecimal('1.00000000000000000000000001'), '1.00000000000000000000000001']},
       :string=>{:db_type=>'text', :class=>String, :convert=>[1, '1', "'1'"]},
       :bigint=>{:class=>Integer, :convert=>['1', 1, '1']},
       :boolean=>{:class=>TrueClass, :convert=>['t', true, 'true']},

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -12,7 +12,6 @@ describe "pg_auto_constraint_validations plugin" do
 
   before do
     info = @info = {:schema=>'public', :table=>'items'}
-    error = @error = []
     @db = Sequel.mock(:host=>'postgres')
     def @db.schema(*) [[:i, {}], [:id, {}]] end
     @set_error = lambda{|ec, ei| @db.fetch = @db.autoid = @db.numrows = ec; info.merge!(ei)}

data/spec/extensions/pg_range_spec.rb

@@ -43,7 +43,7 @@ describe "pg_range extension" do
     @db.literal(DateTime.new(2011, 1, 2, 10, 20, 30)...DateTime.new(2011, 2, 3, 10, 20, 30)).must_equal "'[2011-01-02 10:20:30,2011-02-03 10:20:30)'"
     @db.literal(1..2).must_equal "'[1,2]'"
     @db.literal(1.0..2.0).must_equal "'[1.0,2.0]'"
-    @db.literal(BigDecimal.new('1.0')..BigDecimal.new('2.0')).must_equal "'[1.0,2.0]'"
+    @db.literal(BigDecimal('1.0')..BigDecimal('2.0')).must_equal "'[1.0,2.0]'"
     @db.literal(Sequel.lit('a')..Sequel.lit('z')).must_equal "'[a,z]'"
     @db.literal(''..'()[]",\\2').must_equal "'[\"\",\\(\\)\\[\\]\\\"\\,\\\\2]'"
   end

data/spec/extensions/schema_dumper_spec.rb

@@ -673,8 +673,8 @@ END_MIG
       s
     end
     e = RUBY_VERSION >= '2.4' ? 'e' : 'E'
-    @d.dump_table_schema(:t4).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal.new(\"0.1005#{e}3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.new(2008, 10, 29)\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30.0\"), :only_time=>true\n  String :c10\n  Date :c11, :default=>Sequel::CURRENT_DATE\n  DateTime :c12, :default=>Sequel::CURRENT_TIMESTAMP\nend"
-    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005#{e}3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.new(2008, 10, 29)\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30.0\")\n  column :c10, \"foo\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\n  column :c11, \"date\", :default=>Sequel::CURRENT_DATE\n  column :c12, \"timestamp\", :default=>Sequel::CURRENT_TIMESTAMP\nend"
+    @d.dump_table_schema(:t4).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal(\"0.1005#{e}3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.new(2008, 10, 29)\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30.0\"), :only_time=>true\n  String :c10\n  Date :c11, :default=>Sequel::CURRENT_DATE\n  DateTime :c12, :default=>Sequel::CURRENT_TIMESTAMP\nend"
+    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal(\"0.1005#{e}3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.new(2008, 10, 29)\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30.0\")\n  column :c10, \"foo\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\n  column :c11, \"date\", :default=>Sequel::CURRENT_DATE\n  column :c12, \"timestamp\", :default=>Sequel::CURRENT_TIMESTAMP\nend"
   end
   
   it "should not use a literal string as a fallback if using MySQL with the :same_db option" do

data/spec/extensions/sql_expr_spec.rb

@@ -24,7 +24,7 @@ describe "Sequel sql_expr extension" do
   end
 
   it "Numeric#sql_expr should wrap the object in a NumericExpression" do
-    [1, 2.0, 2^70, BigDecimal.new('1.0')].each do |o|
+    [1, 2.0, 2^70, BigDecimal('1.0')].each do |o|
       @ds.literal(o.sql_expr).must_equal @ds.literal(o)
       @ds.literal(o.sql_expr + 1).must_equal "(#{@ds.literal(o)} + 1)"
     end

data/spec/extensions/string_agg_spec.rb

@@ -79,7 +79,7 @@ describe "string_agg extension" do
   it "should handle operations on object" do
     ds = dbf.call(:postgres).dataset.with_quote_identifiers(false)
     ds.literal(@sa1 + 'b').must_equal "(string_agg(c, ',') || 'b')"
-    ds.literal(@sa1.like('b')).must_equal "(string_agg(c, ',') LIKE 'b' ESCAPE '\\')"
+    ds.literal(@sa1.like('b')).must_equal "(string_agg(c, ',') LIKE 'b')"
     ds.literal(@sa1 < 'b').must_equal "(string_agg(c, ',') < 'b')"
     ds.literal(@sa1.as(:b)).must_equal "string_agg(c, ',') AS b"
     ds.literal(@sa1.cast(:b)).must_equal "CAST(string_agg(c, ',') AS b)"

data/spec/extensions/timestamps_spec.rb

@@ -63,9 +63,9 @@ describe "Sequel::Plugins::Timestamps" do
   it "should work with current_datetime_timestamp extension" do
     Sequel.datetime_class = Time
     @c.dataset = @c.dataset.extension(:current_datetime_timestamp)
-    o = @c.create
+    @c.create
     @c.db.sqls.must_equal ["INSERT INTO t (created_at) VALUES (CURRENT_TIMESTAMP)"]
-    o = @c.load(:id=>1).save
+    @c.load(:id=>1).save
     @c.db.sqls.must_equal ["UPDATE t SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
   end
 

data/spec/extensions/validation_helpers_spec.rb

@@ -293,7 +293,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @m.must_be :valid?
     @m.value = 1.0
     @m.must_be :valid?
-    @m.value = BigDecimal.new('1.0')
+    @m.value = BigDecimal('1.0')
     @m.wont_be :valid?
     @m.errors.full_messages.must_equal ['value is not a valid integer or float']
   end

data/spec/integration/associations_test.rb

@@ -2059,6 +2059,18 @@ describe "Sequel::Model Simple Associations" do
     artist.albums.first.tags.must_equal [tag2]
   end
   
+  it "should not produce duplicates when eager graphing many_to_one=>one_to_many association" do
+    @pr.call
+    @album.update(:artist => @artist)
+    album2 = Album.last
+    album2.update(:artist => @artist)
+
+    a = Album.eager_graph(:artist=>:albums).order{[albums[:id], albums_0[:id]]}.all
+    a.must_equal [@album, album2]
+    a.map(&:artist).must_equal [@artist, @artist]
+    a.map(&:artist).map(&:albums).must_equal [[@album, album2], [@album, album2]]
+  end
+
   it "should have remove method raise an error for one_to_many records if the object isn't already associated" do
     proc{@artist.remove_album(@album.id)}.must_raise(Sequel::Error)
     proc{@artist.remove_album(@album)}.must_raise(Sequel::Error)

data/spec/integration/dataset_test.rb

@@ -1698,6 +1698,27 @@ describe "Dataset string methods" do
     @ds.filter(Sequel.expr(:b).ilike(@ds.escape_like('[Bar%]'))).select_order_map(:b).must_equal ['[bar%]']
     @ds.filter(Sequel.expr(:b).ilike("#{@ds.escape_like('Bar%')}_")).select_order_map(:b).must_equal ['bar%.']
     @ds.filter(Sequel.expr(:b).ilike("#{@ds.escape_like('Bar%')}%")).select_order_map(:b).must_equal ['bar%', 'bar%.', 'bar%..']
+
+    Sequel.extension(:escaped_like)
+    @ds.filter(Sequel.expr(:a).escaped_like('?', 'Foo_')).select_order_map(:a).must_equal []
+    @ds.filter(Sequel.expr(:a).escaped_like('?', 'foo_')).select_order_map(:a).must_equal ['foo_']
+    @ds.filter(Sequel.expr(:b).escaped_like('?', ['bar%'])).select_order_map(:b).must_equal ['bar%']
+    @ds.filter(Sequel.expr(:a).escaped_like('??', ['fo', 'o\\_'])).select_order_map(:a).must_equal ['foo\\_']
+    @ds.filter(Sequel.expr(:b).escaped_like('?', 'bar\\%')).select_order_map(:b).must_equal ['bar\\%']
+    @ds.filter(Sequel.expr(:a).escaped_like('?', '[f#*?oo_]')).select_order_map(:a).must_equal ['[f#*?oo_]']
+    @ds.filter(Sequel.expr(:b).escaped_like('?', '[bar%]')).select_order_map(:b).must_equal ['[bar%]']
+    @ds.filter(Sequel.expr(:b).escaped_like('?_', 'bar%')).select_order_map(:b).must_equal ['bar%.']
+    @ds.filter(Sequel.expr(:b).escaped_like('?%', 'bar%')).select_order_map(:b).must_equal ['bar%', 'bar%.', 'bar%..']
+
+    @ds.filter(Sequel.expr(:a).escaped_ilike('?', 'Foo_')).select_order_map(:a).must_equal ['foo_']
+    @ds.filter(Sequel.expr(:a).escaped_ilike('?', 'Foo_')).select_order_map(:a).must_equal ['foo_']
+    @ds.filter(Sequel.expr(:b).escaped_ilike('?', ['Bar%'])).select_order_map(:b).must_equal ['bar%']
+    @ds.filter(Sequel.expr(:a).escaped_ilike('??', ['Fo', 'o\\_'])).select_order_map(:a).must_equal ['foo\\_']
+    @ds.filter(Sequel.expr(:b).escaped_ilike('?', 'Bar\\%')).select_order_map(:b).must_equal ['bar\\%']
+    @ds.filter(Sequel.expr(:a).escaped_ilike('?', '[F#*?oo_]')).select_order_map(:a).must_equal ['[f#*?oo_]']
+    @ds.filter(Sequel.expr(:b).escaped_ilike('?', '[Bar%]')).select_order_map(:b).must_equal ['[bar%]']
+    @ds.filter(Sequel.expr(:b).escaped_ilike('?_', 'Bar%')).select_order_map(:b).must_equal ['bar%.']
+    @ds.filter(Sequel.expr(:b).escaped_ilike('?%', 'Bar%')).select_order_map(:b).must_equal ['bar%', 'bar%.', 'bar%..']
   end
   
   if DB.dataset.supports_regexp?

data/spec/integration/type_test.rb

@@ -45,11 +45,11 @@ describe "Supported types" do
   
   cspecify "should support generic numeric type", [:odbc, :mssql] do
     ds = create_items_table_with_column(:number, Numeric, :size=>[15, 10])
-    ds.insert(:number => BigDecimal.new('2.123456789'))
-    ds.all.must_equal [{:number=>BigDecimal.new('2.123456789')}]
+    ds.insert(:number => BigDecimal('2.123456789'))
+    ds.all.must_equal [{:number=>BigDecimal('2.123456789')}]
     ds = create_items_table_with_column(:number, BigDecimal, :size=>[15, 10])
-    ds.insert(:number => BigDecimal.new('2.123456789'))
-    ds.all.must_equal [{:number=>BigDecimal.new('2.123456789')}]
+    ds.insert(:number => BigDecimal('2.123456789'))
+    ds.all.must_equal [{:number=>BigDecimal('2.123456789')}]
   end
 
   it "should support generic string type" do

data/spec/model/base_spec.rb

@@ -100,6 +100,15 @@ describe Sequel::Model, "dataset" do
   end
 end
   
+describe Sequel::Model, "has_dataset?" do
+  it "should return whether the model has a dataset" do
+    c = Class.new(Sequel::Model)
+    c.has_dataset?.must_equal false
+    c.dataset = c.db[:table]
+    c.has_dataset?.must_equal true
+  end
+end
+
 describe Sequel::Model, "implicit table names" do
   after do
     Object.send(:remove_const, :BlahBlah)

data/spec/model/eager_loading_spec.rb

@@ -2168,6 +2168,21 @@ describe Sequel::Model, "#eager_graph" do
     a.al_genre.must_equal GraphGenre.load(:id=>12)
   end
 
+  it "should not include duplicate objects when eager graphing many_to_one=>one_to_many" do
+    ds = GraphAlbum.eager_graph(:band=>:albums)
+    ds.sql.must_equal "SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, albums_0.id AS albums_0_id, albums_0.band_id AS albums_0_band_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.band_id = band.id)"
+    a = ds.with_fetch([
+      {:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>1, :albums_0_id=>1, :albums_0_band_id=>2},
+      {:id=>2, :band_id=>2, :band_id_0=>2, :vocalist_id=>1, :albums_0_id=>1, :albums_0_band_id=>2},
+      {:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>1, :albums_0_id=>2, :albums_0_band_id=>2},
+      {:id=>2, :band_id=>2, :band_id_0=>2, :vocalist_id=>1, :albums_0_id=>2, :albums_0_band_id=>2}
+    ]).all
+    albums = [GraphAlbum.load(:id => 1, :band_id => 2), GraphAlbum.load(:id => 2, :band_id => 2)]
+    a.must_equal albums
+    a.map(&:band).must_equal [GraphBand.load(:id=>2, :vocalist_id=>1), GraphBand.load(:id=>2, :vocalist_id=>1)]
+    a.map(&:band).map(&:albums).must_equal [albums, albums]
+  end
+
   it "should eagerly load a many_to_one association with a custom callback" do
     ds = GraphAlbum.eager_graph(:band => proc {|ds1| ds1.select(:id).columns(:id)})
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0 FROM albums LEFT OUTER JOIN (SELECT id FROM bands) AS band ON (band.id = albums.band_id)'
@@ -2229,6 +2244,16 @@ describe Sequel::Model, "#eager_graph" do
     a.album.band.must_equal GraphBand.load(:id => 2, :vocalist_id=>6)
     a.album.tracks.must_equal [GraphTrack.load(:id => 3, :album_id => 1)]
   end
+
+  it "should have frozen internal data structures" do
+    ds = GraphAlbum.eager_graph(:band)
+    ds.opts[:eager_graph].must_be :frozen?
+    ds.opts[:eager_graph].each_value{|v| v.must_be :frozen? if v.is_a?(Hash)}
+
+    ds = ds.eager_graph(:tracks)
+    ds.opts[:eager_graph].must_be :frozen?
+    ds.opts[:eager_graph].each_value{|v| v.must_be :frozen? if v.is_a?(Hash)}
+  end
 end
 
 describe "Sequel::Models with double underscores in table names" do

data/spec/model/record_spec.rb

@@ -1835,7 +1835,7 @@ describe Sequel::Model, "typecasting" do
   it "should convert to BigDecimal for a decimal field" do
     @c.db_schema = {:x=>{:type=>:decimal}}
     m = @c.new
-    bd = BigDecimal.new('1.0')
+    bd = BigDecimal('1.0')
     m.x = '1.0'
     m.x.must_equal bd
     m.x = 1.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.8.0
+  version: 5.9.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-01 00:00:00.000000000 Z
+date: 2018-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -192,6 +192,7 @@ extra_rdoc_files:
 - doc/release_notes/5.4.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.7.0.txt
+- doc/release_notes/5.9.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -278,6 +279,7 @@ files:
 - doc/release_notes/5.6.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
+- doc/release_notes/5.9.0.txt
 - doc/schema_modification.rdoc
 - doc/security.rdoc
 - doc/sharding.rdoc
@@ -385,6 +387,7 @@ files:
 - lib/sequel/extensions/duplicate_columns_handler.rb
 - lib/sequel/extensions/empty_array_consider_nulls.rb
 - lib/sequel/extensions/error_sql.rb
+- lib/sequel/extensions/escaped_like.rb
 - lib/sequel/extensions/eval_inspect.rb
 - lib/sequel/extensions/freeze_datasets.rb
 - lib/sequel/extensions/from_block.rb
@@ -596,6 +599,7 @@ files:
 - spec/extensions/empty_array_consider_nulls_spec.rb
 - spec/extensions/error_splitter_spec.rb
 - spec/extensions/error_sql_spec.rb
+- spec/extensions/escaped_like_spec.rb
 - spec/extensions/eval_inspect_spec.rb
 - spec/extensions/finder_spec.rb
 - spec/extensions/force_encoding_spec.rb