sequel 5.27.0 → 5.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 512f72ad99402b33be776e759611a9299b638f49344fb1f349120c8cd1643107
-  data.tar.gz: ea0852b3ea61ef9a5a192637a2b457fe47f2374c8ee2eb20d9b02e6eb25a25ac
+  metadata.gz: e206de897422ca8260c788bcfc20bcb154c9122dd17a12dc4b45ecdca023eb9a
+  data.tar.gz: 319df67cbb77d1b93d12cd0a1f429de0b674543ebd62b6407d40e1bd992e2352
 SHA512:
-  metadata.gz: 4397a4a7530bd3234d7c1e3bf8b1c2b8a6845e659b86b7177dc704edf8ebf2185c499ac7ba04bb7d52006cf1367b8c0835787be1483e7bb481fa4ea2d775680b
-  data.tar.gz: 653238c46ae32bd74127bddb87dc4c99637f5eadfb7515a51e8da5bc57df10de57c2e9a97d085828cc45b97303fa66580c1c8832a5f6fbb5cdaffd585ce0ff86
+  metadata.gz: a69c5b0bdfdb9c32503204b19d7dc18a7f78f7af7d46c44a7a4413ed4561c3ed3d0a796742045b158714a45f165957a0b9e5d6830bb110e53872a17a1ccb1ed8
+  data.tar.gz: 73a7df723afa66c70f72218e0327f10ef659a22614e5a4438d8fdc2ba16ec97d6e33213c4fd2ed08e806f2860f968786543015b34f38449093d71194aadb3655

data/CHANGELOG

@@ -1,3 +1,11 @@
+=== 5.28.0 (2020-01-01)
+
+* Warn when calling Sequel::JDBC::Postgres::Dataset#with_fetch_size (jeremyevans) (#1665)
+
+* Add exclude_or_null extension, for filtering datasets where the condition is false or NULL (jeremyevans)
+
+* Add any_not_empty extension, for making Dataset#any? without a block mean !empty? (jeremyevans)
+
 === 5.27.0 (2019-12-01)
 
 * Add Sequel::DEFAULT for a DEFAULT expression, useful for assigning to default values (jeremyevans)

data/doc/cheat_sheet.rdoc

@@ -55,6 +55,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 
   dataset.exclude(:active).delete
   dataset.where{price < 100}.update(:active => true)
+  dataset.where(:active).update(:price => Sequel[:price] * 0.90)
 
 == Datasets are Enumerable
 

data/doc/release_notes/5.28.0.txt

@@ -0,0 +1,16 @@
+= New Features
+
+* An any_not_empty extension has been added, for making Dataset#any?
+  without a block be the same as !empty?.  This can result in a
+  much faster database query.
+
+* An exclude_or_null extension has been added, adding a
+  Dataset#exclude_or_null method that returns rows where the given
+  expression is false or NULL.  This extension is supported on
+  PostgreSQL, SQLite, MySQL, H2, and HSQLDB.
+
+= Other Improvements
+
+* When using the jdbc/postgresql adapter, calling with_fetch_size
+  on a dataset will emit a warning.  This is because the driver
+  will ignore the setting.

data/doc/testing.rdoc

@@ -8,17 +8,20 @@ These run each test in its own transaction, the recommended way to test.
 
 === minitest/spec
 
-==== with minitest-hooks
-
+==== with minitest-hooks    
   require 'minitest/hooks/default'
+  
+  DB = Sequel.postgres # change if using sqlite etc
+  
   class Minitest::HooksSpec
     def around
       DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
-==== without minitest-hooks
-
+==== without minitest-hooks  
+  DB = Sequel.postgres # change if using sqlite etc
+  
   class Minitest::Spec
     def run(*args, &block)
       DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
@@ -26,7 +29,8 @@ These run each test in its own transaction, the recommended way to test.
   end
 
 === minitest/test
-
+  DB = Sequel.postgres # change if using sqlite etc
+  
   # Use this class as the base class for your tests
   class SequelTestCase < Minitest::Test
     def run(*args, &block)
@@ -35,7 +39,8 @@ These run each test in its own transaction, the recommended way to test.
   end
 
 === rspec >= 2.8
-
+  DB = Sequel.postgres # change the database if you are using sqlite etc.
+  
   RSpec.configure do |c|
     c.around(:each) do |example|
       DB.transaction(:rollback=>:always, :auto_savepoint=>true){example.run}

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -180,6 +180,12 @@ module Sequel
       
       class Dataset < JDBC::Dataset
         include Sequel::Postgres::DatasetMethods
+
+        # Warn when calling as the fetch size is ignored by the JDBC adapter currently.
+        def with_fetch_size(size)
+          warn("Sequel::JDBC::Postgres::Dataset#with_fetch_size does not currently have an effect.", :uplevel=>1)
+          super
+        end
         
         private
         

data/lib/sequel/dataset/query.rb

@@ -1237,6 +1237,20 @@ module Sequel
       self
     end
 
+    # If invert is true, invert the condition.
+    def _invert_filter(cond, invert)
+      if invert
+        SQL::BooleanExpression.invert(cond)
+      else
+        cond
+      end
+    end
+
+    # Add the given filter condition. Arguments:
+    # clause :: Symbol or which SQL clause to effect, should be :where or :having
+    # cond :: The filter condition to add
+    # invert :: Whether the condition should be inverted (true or false)
+    # combine :: How to combine the condition with an existing condition, should be :AND or :OR
     def add_filter(clause, cond, invert=false, combine=:AND, &block)
       if cond == EMPTY_ARRAY && !block
         raise Error, "must provide an argument to a filtering method if not passing a block"
@@ -1256,8 +1270,7 @@ module Sequel
           cond = nil
         end
 
-        cond = filter_expr(cond, &block)
-        cond = SQL::BooleanExpression.invert(cond) if invert
+        cond = _invert_filter(filter_expr(cond, &block), invert)
         cond = SQL::BooleanExpression.new(combine, @opts[clause], cond) if @opts[clause]
 
         if cond.nil?

data/lib/sequel/extensions/any_not_empty.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+#
+# The any_not_empty extension changes the behavior of Dataset#any?
+# if called without a block.  By default, this method uses the
+# standard Enumerable behavior of enumerating results and seeing
+# if any result is not false or nil.  With this extension, it
+# just checks whether the dataset is empty.  This approach can
+# be much faster if the dataset is currently large.
+#
+#   DB[:table].any?
+#   # SELECT * FROM table
+#
+#   DB[:table].extension(:any_not_empty).any?
+#   # SELECT 1 as one FROM table LIMIT 1
+#   
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:any_not_empty)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:any_not_empty)
+#
+# Note that this can result in any? returning a different result if
+# the dataset has a row_proc that can return false or nil.
+#
+# Related module: Sequel::AnyNotEmpty
+
+#
+module Sequel
+  module AnyNotEmpty
+    # If a block is not given, return whether the dataset is not empty.
+    def any?
+      if block_given?
+        super
+      else
+        !empty?
+      end
+    end
+  end
+
+  Dataset.register_extension(:any_not_empty, AnyNotEmpty)
+end

data/lib/sequel/extensions/exclude_or_null.rb

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+#
+# The exclude_or_null extension adds Dataset#exclude_or_null and
+# Dataset#exclude_or_null_having.  These methods are similar to
+# Dataset#exclude and Dataset#exclude_having, except that they
+# will also exclude rows where the condition IS NULL.
+#
+#   DB[:table].exclude_or_null(foo: 1)
+#   # SELECT * FROM table WHERE NOT coalesce((foo = 1), false)
+#   
+#   DB[:table].exclude_or_null{foo(bar) =~ 1}
+#   # SELECT * FROM table HAVING NOT coalesce((foo(bar) = 1), false))
+#   
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:exclude_or_null)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:exclude_or_null)
+#
+# Note, this extension works correctly on PostgreSQL, SQLite, MySQL,
+# H2, and HSQLDB.  However, it does not work correctly on Microsoft SQL Server,
+# Oracle, DB2, SQLAnywhere, or Derby.
+#
+# Related module: Sequel::ExcludeOrNull
+
+#
+module Sequel
+  module ExcludeOrNull
+    # Performs the inverse of Dataset#where, but also excludes rows where the given
+    # condition IS NULL.
+    #
+    #   DB[:items].exclude_or_null(category: 'software')
+    #   # SELECT * FROM items WHERE NOT coalesce((category = 'software'), false)
+    #   
+    #   DB[:items].exclude_or_null(category: 'software', id: 3)
+    #   # SELECT * FROM items WHERE NOT coalesce(((category = 'software') AND (id = 3)), false)
+    def exclude_or_null(*cond, &block)
+      add_filter(:where, cond, :or_null, &block)
+    end
+
+    # The same as exclude_or_null, but affecting the HAVING clause instead of the
+    # WHERE clause.
+    #
+    #   DB[:items].select_group(:name).exclude_or_null_having{count(name) < 2}
+    #   # SELECT name FROM items GROUP BY name HAVING NOT coalesce((count(name) < 2), true)
+    def exclude_or_null_having(*cond, &block)
+      add_filter(:having, cond, :or_null, &block)
+    end
+
+    private
+
+    # Recognize :or_null value for invert, returning an expression for
+    # the invert of the condition or the condition being null.
+    def _invert_filter(cond, invert)
+      if invert == :or_null
+        ~SQL::Function.new(:coalesce, cond, SQL::Constants::SQLFALSE)
+      else
+        super
+      end
+    end
+  end
+
+  Dataset.register_extension(:exclude_or_null, ExcludeOrNull)
+end

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 27
+  MINOR = 28
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/adapters/postgres_spec.rb

@@ -3685,19 +3685,19 @@ describe 'PostgreSQL range types' do
   end if uses_pg_or_jdbc
 
   it 'handle endless ranges' do
-    @db.get(Sequel.cast(eval('1...'), :int4range)).must_be :==, eval('1...')
-    @db.get(Sequel.cast(eval('1...'), :int4range)).wont_be :==, eval('2...')
-    @db.get(Sequel.cast(eval('1...'), :int4range)).wont_be :==, eval('1..')
-    @db.get(Sequel.cast(eval('2...'), :int4range)).must_be :==, eval('2...')
-    @db.get(Sequel.cast(eval('2...'), :int4range)).wont_be :==, eval('2..')
-    @db.get(Sequel.cast(eval('2...'), :int4range)).wont_be :==, eval('1...')
+    @db.get(Sequel.cast(eval('(1...)'), :int4range)).must_be :==, eval('(1...)')
+    @db.get(Sequel.cast(eval('(1...)'), :int4range)).wont_be :==, eval('(2...)')
+    @db.get(Sequel.cast(eval('(1...)'), :int4range)).wont_be :==, eval('(1..)')
+    @db.get(Sequel.cast(eval('(2...)'), :int4range)).must_be :==, eval('(2...)')
+    @db.get(Sequel.cast(eval('(2...)'), :int4range)).wont_be :==, eval('(2..)')
+    @db.get(Sequel.cast(eval('(2...)'), :int4range)).wont_be :==, eval('(1...)')
   end if RUBY_VERSION >= '2.6'
 
   it 'handle startless ranges' do
-    @db.get(Sequel.cast(eval('...1'), :int4range)).must_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
-    @db.get(Sequel.cast(eval('...1'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 2, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
-    @db.get(Sequel.cast(eval('...1'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_end=>true, :db_type=>"int4range")
-    @db.get(Sequel.cast(eval('...1'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('(...1)'), :int4range)).must_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('(...1)'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 2, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('(...1)'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('(...1)'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :db_type=>"int4range")
   end if RUBY_VERSION >= '2.7'
 
   it 'handle startless ranges' do

data/spec/core/database_spec.rb

@@ -2467,7 +2467,7 @@ describe "Database#typecast_value" do
       @db.typecast_value(:date, 'a')
       true.must_equal false
     rescue Sequel::InvalidValue => e
-      e.inspect.must_equal '#<Sequel::InvalidValue: ArgumentError: invalid date>'
+      e.inspect.must_match(/\A#\<Sequel::InvalidValue: (Argument|Date::)Error: invalid date\>\z/)
     end
   end
 end

data/spec/core/expression_filters_spec.rb

@@ -537,21 +537,21 @@ describe "Blockless Ruby Filters" do
   end
 
   it "should handle endless ranges" do
-    endless = eval('1..')
+    endless = eval('(1..)')
     @d.l{x =~ endless}.must_equal '(x >= 1)'
     @d.l(:x => endless).must_equal '(x >= 1)'
 
-    endless = eval('1...')
+    endless = eval('(1...)')
     @d.l{x =~ endless}.must_equal '(x >= 1)'
     @d.l(:x => endless).must_equal '(x >= 1)'
   end if RUBY_VERSION >= '2.6'
 
   it "should handle startless ranges" do
-    endless = eval('..1')
+    endless = eval('(..1)')
     @d.l{x =~ endless}.must_equal '(x <= 1)'
     @d.l(:x => endless).must_equal '(x <= 1)'
 
-    endless = eval('...1')
+    endless = eval('(...1)')
     @d.l{x =~ endless}.must_equal '(x < 1)'
     @d.l(:x => endless).must_equal '(x < 1)'
   end if RUBY_VERSION >= '2.7'

data/spec/extensions/any_not_empty_spec.rb

@@ -0,0 +1,23 @@
+require_relative "spec_helper"
+
+describe "any_not_empty extension" do
+  before do
+    @ds = Sequel.mock[:t].extension(:any_not_empty)
+  end
+
+  it "should use a limited query if no block is given" do
+    @ds.with_fetch(:one=>1).any?.must_equal true
+    @ds.db.sqls.must_equal ["SELECT 1 AS one FROM t LIMIT 1"]
+    @ds.with_fetch([]).any?.must_equal false
+    @ds.db.sqls.must_equal ["SELECT 1 AS one FROM t LIMIT 1"]
+  end
+
+  it "should use default behavior if block is given" do
+    @ds.with_fetch(:one=>1).any?{|x| x[:one] == 1}.must_equal true
+    @ds.db.sqls.must_equal ["SELECT * FROM t"]
+    @ds.with_fetch(:one=>1).any?{|x| x[:one] != 1}.must_equal false
+    @ds.db.sqls.must_equal ["SELECT * FROM t"]
+    @ds.with_fetch([]).any?{|x| x[:one] == 1}.must_equal false
+    @ds.db.sqls.must_equal ["SELECT * FROM t"]
+  end
+end

data/spec/extensions/exclude_or_null_spec.rb

@@ -0,0 +1,15 @@
+require_relative "spec_helper"
+
+describe "exclude_or_null extension" do
+  before do
+    @ds = Sequel.mock[:t].extension(:exclude_or_null)
+  end
+
+  it "should add condition where a is false or NULL" do
+    @ds.exclude_or_null(:a).sql.must_equal "SELECT * FROM t WHERE NOT coalesce(a, 'f')"
+  end
+
+  it "should not effect normal exclude" do
+    @ds.exclude(:a).sql.must_equal "SELECT * FROM t WHERE NOT a"
+  end
+end

data/spec/extensions/pg_range_spec.rb

@@ -52,13 +52,13 @@ describe "pg_range extension" do
   end
 
   it "should literalize endless Range instances to strings correctly" do
-    @db.literal(eval('1..')).must_equal "'[1,]'"
-    @db.literal(eval('1...')).must_equal "'[1,)'"
+    @db.literal(eval('(1..)')).must_equal "'[1,]'"
+    @db.literal(eval('(1...)')).must_equal "'[1,)'"
   end if endless_range_support
 
   it "should literalize startless Range instances to strings correctly" do
-    @db.literal(eval('..1')).must_equal "'[,1]'"
-    @db.literal(eval('...1')).must_equal "'[,1)'"
+    @db.literal(eval('(..1)')).must_equal "'[,1]'"
+    @db.literal(eval('(...1)')).must_equal "'[,1)'"
   end if startless_range_support
 
   it "should literalize startless, endless Range instances to strings correctly" do
@@ -90,13 +90,13 @@ describe "pg_range extension" do
   end
 
   it "should support using endless Range instances as bound variables" do
-    @db.bound_variable_arg(eval('1..'), nil).must_equal "[1,]"
-    @db.bound_variable_arg(eval('1...'), nil).must_equal "[1,)"
+    @db.bound_variable_arg(eval('(1..)'), nil).must_equal "[1,]"
+    @db.bound_variable_arg(eval('(1...)'), nil).must_equal "[1,)"
   end if endless_range_support
 
   it "should support using startless Range instances as bound variables" do
-    @db.bound_variable_arg(eval('..1'), nil).must_equal "[,1]"
-    @db.bound_variable_arg(eval('...1'), nil).must_equal "[,1)"
+    @db.bound_variable_arg(eval('(..1)'), nil).must_equal "[,1]"
+    @db.bound_variable_arg(eval('(...1)'), nil).must_equal "[,1)"
   end if startless_range_support
 
   it "should support using startless, endless Range instances as bound variables" do
@@ -113,7 +113,7 @@ describe "pg_range extension" do
   end
 
   it "should support using arrays of endless Range instances as bound variables" do
-    @db.bound_variable_arg([eval('1..'), eval('2..')], nil).must_equal '{"[1,]","[2,]"}'
+    @db.bound_variable_arg([eval('(1..)'), eval('(2..)')], nil).must_equal '{"[1,]","[2,]"}'
   end if endless_range_support
 
   it "should support using PGRange instances as bound variables" do
@@ -470,21 +470,21 @@ describe "pg_range extension" do
     end
 
     it "should consider PGRanges equal with a endless Range they represent" do
-      @R.new(1, nil).must_be :==, eval('1..')
-      @R.new(1, nil, :exclude_end=>true).must_be :==, eval('1...')
-      @R.new(1, nil).wont_be :==, eval('1...')
-      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('1..')
-      @R.new(1, nil).wont_be :==, eval('2..')
-      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('2...')
+      @R.new(1, nil).must_be :==, eval('(1..)')
+      @R.new(1, nil, :exclude_end=>true).must_be :==, eval('(1...)')
+      @R.new(1, nil).wont_be :==, eval('(1...)')
+      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('(1..)')
+      @R.new(1, nil).wont_be :==, eval('(2..)')
+      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('(2...)')
     end if endless_range_support
 
     it "should consider PGRanges equal with a startless Range they represent" do
-      @R.new(nil, 1).must_be :==, eval('..1')
-      @R.new(nil, 1, :exclude_end=>true).must_be :==, eval('...1')
-      @R.new(nil, 1).wont_be :==, eval('...1')
-      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('..1')
-      @R.new(nil, 1).wont_be :==, eval('..2')
-      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('...2')
+      @R.new(nil, 1).must_be :==, eval('(..1)')
+      @R.new(nil, 1, :exclude_end=>true).must_be :==, eval('(...1)')
+      @R.new(nil, 1).wont_be :==, eval('(...1)')
+      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('(..1)')
+      @R.new(nil, 1).wont_be :==, eval('(..2)')
+      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('(...2)')
     end if startless_range_support
 
     it "should consider PGRanges equal with a startless, endless Range they represent" do

data/spec/integration/dataset_test.rb

@@ -593,22 +593,21 @@ describe Sequel::Dataset do
 end
 
 describe "Simple Dataset operations" do
-  before do
+  before(:all) do
     DB.create_table!(:items) do
       Integer :number
       TrueClass :flag
     end
-    @ds = DB[:items]
+    @ds = DB[:items].order(:number)
+    @ds.insert(:number=>1, :flag=>true)
+    @ds.insert(:number=>2, :flag=>false)
+    @ds.insert(:number=>3, :flag=>nil)
   end
-  after do
+  after(:all) do
     DB.drop_table?(:items)
   end
 
   it "should deal with boolean conditions correctly" do
-    @ds.insert(:number=>1, :flag=>true)
-    @ds.insert(:number=>2, :flag=>false)
-    @ds.insert(:number=>3, :flag=>nil)
-    @ds = @ds.order(:number)
     @ds.filter(:flag=>true).map(:number).must_equal [1]
     @ds.filter(:flag=>false).map(:number).must_equal [2]
     @ds.filter(:flag=>nil).map(:number).must_equal [3]
@@ -616,6 +615,22 @@ describe "Simple Dataset operations" do
     @ds.exclude(:flag=>false).map(:number).must_equal [1, 3]
     @ds.exclude(:flag=>nil).map(:number).must_equal [1, 2]
   end
+
+  cspecify "should deal with boolean equality conditions correctly", :derby do
+    @ds.filter(true=>:flag).map(:number).must_equal [1]
+    @ds.filter(false=>:flag).map(:number).must_equal [2]
+    @ds.filter(nil=>:flag).map(:number).must_equal []
+    @ds.exclude(true=>:flag).map(:number).must_equal [2]
+    @ds.exclude(false=>:flag).map(:number).must_equal [1]
+    @ds.exclude(nil=>:flag).map(:number).must_equal []
+  end
+
+  cspecify "should have exclude_or_null work correctly", :mssql, :derby, :oracle, :db2, :sqlanywhere do
+    @ds = @ds.extension(:exclude_or_null)
+    @ds.exclude_or_null(true=>:flag).map(:number).must_equal [2, 3]
+    @ds.exclude_or_null(false=>:flag).map(:number).must_equal [1, 3]
+    @ds.exclude_or_null(nil=>:flag).map(:number).must_equal [1, 2, 3]
+  end
 end
 
 describe "Simple Dataset operations in transactions" do
@@ -1578,20 +1593,20 @@ describe "Sequel::Dataset DSL support" do
   
   it "should work with endless ranges as hash values" do
     @ds.insert(20, 10)
-    @ds.filter(:a=>eval('30..')).all.must_equal []
-    @ds.filter(:a=>eval('20...')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('20..')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('10..')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(30..)')).all.must_equal []
+    @ds.filter(:a=>eval('(20...)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(20..)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(10..)')).all.must_equal [{:a=>20, :b=>10}]
   end if RUBY_VERSION >= '2.6'
   
   it "should work with startless ranges as hash values" do
     @ds.insert(20, 10)
-    @ds.filter(:a=>eval('..30')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('...30')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('..20')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('...20')).all.must_equal []
-    @ds.filter(:a=>eval('..10')).all.must_equal []
-    @ds.filter(:a=>eval('...10')).all.must_equal []
+    @ds.filter(:a=>eval('(..30)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(...30)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(..20)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(...20)')).all.must_equal []
+    @ds.filter(:a=>eval('(..10)')).all.must_equal []
+    @ds.filter(:a=>eval('(...10)')).all.must_equal []
 
     @ds.filter(:a=>eval('nil..nil')).all.must_equal [{:a=>20, :b=>10}]
   end if RUBY_VERSION >= '2.7'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.27.0
+  version: 5.28.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-01 00:00:00.000000000 Z
+date: 2020-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -225,6 +225,7 @@ extra_rdoc_files:
 - doc/release_notes/5.25.0.txt
 - doc/release_notes/5.26.0.txt
 - doc/release_notes/5.27.0.txt
+- doc/release_notes/5.28.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -323,6 +324,7 @@ files:
 - doc/release_notes/5.25.0.txt
 - doc/release_notes/5.26.0.txt
 - doc/release_notes/5.27.0.txt
+- doc/release_notes/5.28.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt
 - doc/release_notes/5.5.0.txt
@@ -421,6 +423,7 @@ files:
 - lib/sequel/extensions/_model_constraint_validations.rb
 - lib/sequel/extensions/_model_pg_row.rb
 - lib/sequel/extensions/_pretty_table.rb
+- lib/sequel/extensions/any_not_empty.rb
 - lib/sequel/extensions/arbitrary_servers.rb
 - lib/sequel/extensions/auto_literal_strings.rb
 - lib/sequel/extensions/blank.rb
@@ -441,6 +444,7 @@ files:
 - lib/sequel/extensions/error_sql.rb
 - lib/sequel/extensions/escaped_like.rb
 - lib/sequel/extensions/eval_inspect.rb
+- lib/sequel/extensions/exclude_or_null.rb
 - lib/sequel/extensions/freeze_datasets.rb
 - lib/sequel/extensions/from_block.rb
 - lib/sequel/extensions/graph_each.rb
@@ -619,6 +623,7 @@ files:
 - spec/extensions/accessed_columns_spec.rb
 - spec/extensions/active_model_spec.rb
 - spec/extensions/after_initialize_spec.rb
+- spec/extensions/any_not_empty_spec.rb
 - spec/extensions/arbitrary_servers_spec.rb
 - spec/extensions/association_dependencies_spec.rb
 - spec/extensions/association_multi_add_remove_spec.rb
@@ -662,6 +667,7 @@ files:
 - spec/extensions/error_sql_spec.rb
 - spec/extensions/escaped_like_spec.rb
 - spec/extensions/eval_inspect_spec.rb
+- spec/extensions/exclude_or_null_spec.rb
 - spec/extensions/finder_spec.rb
 - spec/extensions/force_encoding_spec.rb
 - spec/extensions/freeze_datasets_spec.rb
@@ -883,7 +889,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: The Database Toolkit for Ruby