sequel 5.21.0 → 5.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33b35675e5f68471b8216acbbe10085992616ae93b6f47191c44bb3860b38285
-  data.tar.gz: e1be4ce80c4810a9022505f7e5d0becaa11912f6e91344b860195e6b11438d27
+  metadata.gz: dab3e09e5e2003ee0c53b63f8b628b723be5aeb019bb5b1d2669f7583f589ef3
+  data.tar.gz: 422d4fc893082e88256f0f2ba8b2f82288aea6f7438c0ef68793f30acc2307e0
 SHA512:
-  metadata.gz: fedb31816a3c56136b007317f135072c318e71938c3375feff8c0ab2ec7ddc5744457008266434dff285095b09bfdf78ab33a24b0b4ac255119f9e80ae6758f1
-  data.tar.gz: eea67a798eedf2cb8b10bbf20eaf3b0deb7e9eabd1c9b8f238754ffbbd4afea394caa8b4574db7bda6373db987a8a088f83732ea353591eeca37ee4583d57730
+  metadata.gz: 844854b68bf2b57c802422496b88dc54d9ec97549da18a5b1d5c04a2ac294286de8cff74c6e8e25f21b35e188c1d9abb97ab9eae427b1bce7c0040779f602da2
+  data.tar.gz: 52317931ac3e82d63bc307c7c970bed264e1412af59ba979069ebb4867e89138901a388419a80b41c88b6d581d959ba2650bced6bc146911913d230fd890aec5

data/CHANGELOG

@@ -1,3 +1,17 @@
+=== 5.22.0 (2019-07-01)
+
+* Fix Dataset#multi_insert and #import with return: :primary_key on MSSQL when the dataset has a row_proc (jeremyevans) (#1627)
+
+* Support Dataset#with :materialized option on PostgreSQL 12 for [NOT] MATERIALIZED (jeremyevans)
+
+* Make Database#primary_key_sequence work on tables without serial sequences on PostgreSQL 12 (jeremyevans)
+
+* Support ruby 2.7+ startless ranges in the pg_range extension (jeremyevans)
+
+* Support ruby 2.7+ startless, endless ranges in filters, using an always true condition for them (jeremyevans)
+
+* Support ruby 2.7+ startless ranges in filters, using just a <= or < operator for them (jeremyevans)
+
 === 5.21.0 (2019-06-01)
 
 * Recognize additional DatabaseLockTimeout errors in mysql and mysql2 adapters (jeremyevans)

data/doc/release_notes/5.22.0.txt

@@ -0,0 +1,48 @@
+= New Features
+
+* Sequel now supports Ruby 2.7+ startless ranges in filters:
+
+    DB[:table].where(:column=>(..10))
+    # SELECT * FROM table WHERE (column <= 10)
+
+    DB[:table].where(:column=>(...10))
+    # SELECT * FROM table WHERE (column < 10)
+
+  It also supports startless, endless ranges in filters, using a
+  condition that is always true:
+
+    DB[:table].where(:column=>(nil..nil))
+    # SELECT * FROM table WHERE (1 = 1)
+
+* Sequel now supports startless ranges in the pg_range extension:
+
+    DB.extension :pg_range
+
+    DB[:table].insert(:column=>(..10))
+    # INSERT INTO "table" ("column") VALUES ('[,10]') RETURNING "id"
+
+    DB[:table].insert(:column=>(...10))
+    # INSERT INTO "table" ("column") VALUES ('[,10)') RETURNING "id"
+
+    DB[:table].insert(:column=>(nil..nil))
+    # INSERT INTO "table" ("column") VALUES ('[,]') RETURNING "id"
+
+* Sequel now supports a :materialized option in Dataset#with on
+  PostgreSQL 12+, to control the inlining of common table expressions:
+
+    DB[:t].with(:t, DB[:t2], :materialized=>false)
+    # WITH "t" AS NOT MATERIALIZED (SELECT * FROM "t2")
+    # SELECT * FROM "t"
+
+    DB[:t].with(:t, DB[:t2], :materialized=>true)
+    # WITH "t" AS MATERIALIZED (SELECT * FROM "t2")
+    # SELECT * FROM "t"
+
+= Other Improvements
+
+* Database#primary_key_sequence now works for tables without serial
+  sequences on PostgreSQL 12+.
+
+* Dataset#multi_insert and #import with return: :primary_key option
+  on Microsoft SQL Server now work correctly if the dataset uses
+  a row_proc (e.g. for model datasets).

data/lib/sequel/adapters/shared/mssql.rb

@@ -765,8 +765,9 @@ module Sequel
           output(nil, [SQL::QualifiedIdentifier.new(:inserted, first_primary_key)])._import(columns, values, opts)
         elsif @opts[:output]
           statements = multi_insert_sql(columns, values)
+          ds = naked
           @db.transaction(opts.merge(:server=>@opts[:server])) do
-            statements.map{|st| with_sql(st)}
+            statements.map{|st| ds.with_sql(st)}
           end.first.map{|v| v.length == 1 ? v.values.first : v}
         else
           super

data/lib/sequel/adapters/shared/postgres.rb

@@ -147,10 +147,10 @@ module Sequel
       SELECT_CUSTOM_SEQUENCE_SQL = (<<-end_sql
         SELECT name.nspname AS "schema",
             CASE
-            WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN
-              substr(split_part(def.adsrc, '''', 2),
-                     strpos(split_part(def.adsrc, '''', 2), '.')+1)
-            ELSE split_part(def.adsrc, '''', 2)
+            WHEN split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2) ~ '.' THEN
+              substr(split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2),
+                     strpos(split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2), '.')+1)
+            ELSE split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2)
           END AS "sequence"
         FROM pg_class t
         JOIN pg_namespace  name ON (t.relnamespace = name.oid)
@@ -158,7 +158,7 @@ module Sequel
         JOIN pg_attrdef    def  ON (adrelid = attrelid AND adnum = attnum)
         JOIN pg_constraint cons ON (conrelid = adrelid AND adnum = conkey[1])
         WHERE cons.contype = 'p'
-          AND def.adsrc ~* 'nextval'
+          AND pg_get_expr(def.adbin, attr.attrelid) ~* 'nextval'
       end_sql
       ).strip.gsub(/\s+/, ' ').freeze
 
@@ -1920,6 +1920,18 @@ module Sequel
         opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super
       end
 
+      # Support WITH AS [NOT] MATERIALIZED if :materialized option is used.
+      def select_with_sql_prefix(sql, w)
+        super
+
+        case w[:materialized]
+        when true
+          sql << "MATERIALIZED "
+        when false
+          sql << "NOT MATERIALIZED "
+        end
+      end
+
       # The version of the database server
       def server_version
         db.server_version(@opts[:server])

data/lib/sequel/dataset.rb

@@ -20,8 +20,10 @@ module Sequel
   #   old_posts = posts.where{stamp < Date.today - 7}
   #   davids_old_posts = davids_posts.where{stamp < Date.today - 7}
   #
-  # Datasets are Enumerable objects, so they can be manipulated using any
-  # of the Enumerable methods, such as map, inject, etc.
+  # Datasets are Enumerable objects, so they can be manipulated using many
+  # of the Enumerable methods, such as +map+ and +inject+.  Note that there are some methods
+  # that Dataset defines that override methods defined in Enumerable and result in different
+  # behavior, such as +select+ and +group_by+.
   #
   # For more information, see the {"Dataset Basics" guide}[rdoc-ref:doc/dataset_basics.rdoc].
   class Dataset

data/lib/sequel/dataset/query.rb

@@ -1062,6 +1062,10 @@ module Sequel
     # :args :: Specify the arguments/columns for the CTE, should be an array of symbols.
     # :recursive :: Specify that this is a recursive CTE
     #
+    # PostgreSQL Specific Options:
+    # :materialized :: Set to false to force inlining of the CTE, or true to force not inlining
+    #                  the CTE (PostgreSQL 12+).
+    #
     #   DB[:items].with(:items, DB[:syx].where(Sequel[:name].like('A%')))
     #   # WITH items AS (SELECT * FROM syx WHERE (name LIKE 'A%' ESCAPE '\')) SELECT * FROM items
     def with(name, dataset, opts=OPTS)

data/lib/sequel/dataset/sql.rb

@@ -1510,13 +1510,7 @@ module Sequel
       comma = ', '
       ws.each do |w|
         sql << comma if c
-        quote_identifier_append(sql, w[:name])
-        if args = w[:args]
-         sql << '('
-         identifier_list_append(sql, args)
-         sql << ')'
-        end
-        sql << ' AS '
+        select_with_sql_prefix(sql, w)
         literal_dataset_append(sql, w[:dataset])
         c ||= true
       end
@@ -1530,6 +1524,16 @@ module Sequel
       "WITH "
     end
 
+    def select_with_sql_prefix(sql, w)
+      quote_identifier_append(sql, w[:name])
+      if args = w[:args]
+       sql << '('
+       identifier_list_append(sql, args)
+       sql << ')'
+      end
+      sql << ' AS '
+    end
+
     # Whether the symbol cache should be skipped when literalizing the dataset
     def skip_symbol_cache?
       @opts[:skip_symbol_cache]

data/lib/sequel/extensions/pg_range.rb

@@ -453,13 +453,14 @@ module Sequel
       end
 
       ENDLESS_RANGE_NOT_SUPPORTED = RUBY_VERSION < '2.6'
+      STARTLESS_RANGE_NOT_SUPPORTED = RUBY_VERSION < '2.7'
 
       # Return a ruby Range object for this instance, if one can be created.
       def to_range
         return @range if @range
         raise(Error, "cannot create ruby range for an empty PostgreSQL range") if empty?
         raise(Error, "cannot create ruby range when PostgreSQL range excludes beginning element") if exclude_begin?
-        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") unless self.begin
+        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") if STARTLESS_RANGE_NOT_SUPPORTED && !self.begin
         raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") if ENDLESS_RANGE_NOT_SUPPORTED && !self.end
         @range = Range.new(self.begin, self.end, exclude_end?)
       end
@@ -468,7 +469,7 @@ module Sequel
       # it must have a beginning and an ending (no unbounded ranges), and it cannot exclude
       # the beginning element.
       def valid_ruby_range?
-        !(empty? || exclude_begin? || !self.begin || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end))
+        !(empty? || exclude_begin? || (STARTLESS_RANGE_NOT_SUPPORTED && !self.begin) || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end))
       end
 
       # Whether the beginning of the range is unbounded.

data/lib/sequel/sql.rb

@@ -1086,11 +1086,23 @@ module Sequel
       def self.from_value_pair(l, r)
         case r
         when Range
-          expr = new(:>=, l, r.begin)
+          unless r.begin.nil?
+            begin_expr = new(:>=, l, r.begin)
+          end
           unless r.end.nil?
-            expr = new(:AND, expr, new(r.exclude_end? ? :< : :<=, l, r.end))
+            end_expr = new(r.exclude_end? ? :< : :<=, l, r.end)
+          end
+          if begin_expr
+            if end_expr
+              new(:AND, begin_expr, end_expr)
+            else
+              begin_expr
+            end
+          elsif end_expr
+            end_expr
+          else
+            new(:'=', 1, 1)
           end
-          expr
         when ::Array
           r = r.dup.freeze unless r.frozen?
           new(:IN, l, r)

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 = 21
+  MINOR = 22
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/adapters/postgres_spec.rb

@@ -352,6 +352,26 @@ describe "PostgreSQL", 'INSERT ON CONFLICT' do
   end
 end if DB.server_version >= 90500
 
+describe "A PostgreSQL database" do
+  before do
+    @db = DB
+    @db.create_table!(:cte_test){Integer :id}
+  end
+  after do
+    @db.drop_table?(:cte_test)
+  end
+
+  it "should give correct results for WITH AS [NOT] MATERIALIZED" do
+    @ds = @db[:cte_test]
+    @ds.insert(1)
+    @ds.insert(2)
+    
+    @db[:t].with(:t, @ds, :materialized=>nil).order(:id).map(:id).must_equal [1, 2]
+    @db[:t].with(:t, @ds, :materialized=>true).order(:id).map(:id).must_equal [1, 2]
+    @db[:t].with(:t, @ds, :materialized=>false).order(:id).map(:id).must_equal [1, 2]
+  end
+end if DB.server_version >= 120000
+
 describe "A PostgreSQL database" do
   before(:all) do
     @db = DB
@@ -3581,6 +3601,30 @@ describe 'PostgreSQL range types' do
     @ds.filter(h).call(:delete, @ra).must_equal 1
   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...')
+  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")
+  end if RUBY_VERSION >= '2.7'
+
+  it 'handle startless ranges' do
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).must_be :==, Sequel::Postgres::PGRange.new(nil, nil, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, nil, :exclude_begin=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, nil, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(1, nil, :exclude_begin=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :db_type=>"int4range")
+  end if RUBY_VERSION >= '2.7'
+
   it 'parse default values for schema' do
     @db.create_table!(:items) do
       Integer :j

data/spec/core/dataset_spec.rb

@@ -3434,6 +3434,16 @@ describe "Dataset#multi_insert" do
       'COMMIT']
   end
   
+  it "should handle :return=>:primary_key option if dataset has a row_proc" do
+    @db.autoid = 1
+    @ds.with_row_proc(lambda{|h| Object.new}).multi_insert(@list, :return=>:primary_key).must_equal [1, 2, 3]
+    @db.sqls.must_equal ['BEGIN',
+      "INSERT INTO items (name) VALUES ('abc')",
+      "INSERT INTO items (name) VALUES ('def')",
+      "INSERT INTO items (name) VALUES ('ghi')",
+      'COMMIT']
+  end
+  
   with_symbol_splitting "should handle splittable symbols for tables" do
     @ds = @ds.from(:sch__tab)
     @ds.multi_insert(@list)

data/spec/core/expression_filters_spec.rb

@@ -526,11 +526,35 @@ describe "Blockless Ruby Filters" do
     dsc.new(@d.db).literal(Sequel.trim(:a)).must_equal 'trimFOO(lower(a))'
   end
 
-  it "should endless ranges" do
+  it "should handle endless ranges" do
     endless = eval('1..')
     @d.l{x =~ endless}.must_equal '(x >= 1)'
     @d.l(:x => endless).must_equal '(x >= 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')
+    @d.l{x =~ endless}.must_equal '(x <= 1)'
+    @d.l(:x => endless).must_equal '(x <= 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'
+
+  it "should handle startless, endless ranges" do
+    endless = eval('nil..nil')
+    @d.l{x =~ endless}.must_equal '(1 = 1)'
+    @d.l(:x => endless).must_equal '(1 = 1)'
+
+    endless = eval('nil...nil')
+    @d.l{x =~ endless}.must_equal '(1 = 1)'
+    @d.l(:x => endless).must_equal '(1 = 1)'
+  end if RUBY_VERSION >= '2.7'
 end
 
 describe Sequel::SQL::VirtualRow do

data/spec/extensions/pg_range_spec.rb

@@ -17,6 +17,7 @@ describe "pg_range extension" do
   end
 
   endless_range_support = RUBY_VERSION >= '2.6'
+  startless_range_support = RUBY_VERSION >= '2.7'
 
   it "should set up conversion procs correctly" do
     cp = @db.conversion_procs
@@ -52,8 +53,19 @@ describe "pg_range extension" do
 
   it "should literalize endless Range instances to strings correctly" do
     @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)'"
+  end if startless_range_support
+
+  it "should literalize startless, endless Range instances to strings correctly" do
+    @db.literal(eval('nil..nil')).must_equal "'[,]'"
+    @db.literal(eval('nil...nil')).must_equal "'[,)'"
+  end if startless_range_support
+
   it "should literalize PGRange instances to strings correctly" do
     @db.literal(@R.new(1, 2)).must_equal "'[1,2]'"
     @db.literal(@R.new(true, false)).must_equal "'[true,false]'"
@@ -79,8 +91,19 @@ describe "pg_range extension" do
 
   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,)"
   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)"
+  end if startless_range_support
+
+  it "should support using startless, endless Range instances as bound variables" do
+    @db.bound_variable_arg(eval('nil..nil'), nil).must_equal "[,]"
+    @db.bound_variable_arg(eval('nil...nil'), nil).must_equal "[,)"
+  end if startless_range_support
+
   it "should support using PGRange instances as bound variables" do
     @db.bound_variable_arg(@R.new(1, 2), nil).must_equal "[1,2]"
   end
@@ -431,12 +454,32 @@ describe "pg_range extension" do
 
     it "should consider PGRanges equal with a endless Range they represent" do
       @R.new(1, nil).must_be :==, eval('1..')
-    end if endless_range_support
-
-    it "should not consider a PGRange equal with a Range if it can't be expressed as a range" do
+      @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')
+    end if startless_range_support
+
+    it "should consider PGRanges equal with a startless, endless Range they represent" do
+      @R.new(nil, nil).must_be :==, eval('nil..nil')
+      @R.new(nil, nil, :exclude_end=>true).must_be :==, eval('nil...nil')
+      @R.new(nil, nil).wont_be :==, eval('nil...nil')
+      @R.new(nil, nil, :exclude_end=>true).wont_be :==, eval('nil..nil')
+      @R.new(nil, nil).wont_be :==, eval('nil..1')
+      @R.new(nil, nil).wont_be :==, eval('1..nil')
+      @R.new(1, nil).wont_be :==, eval('nil..nil')
+    end if startless_range_support
+
     it "should not consider a PGRange equal to other objects" do
       @R.new(nil, nil).wont_equal 1
     end
@@ -444,7 +487,6 @@ describe "pg_range extension" do
     it "should have #=== be true if given an equal PGRange" do
       @R.new(1, 2).must_be :===, @R.new(1, 2)
       @R.new(1, 2).wont_be :===, @R.new(1, 3)
-
     end
 
     it "should have #=== be true if it would be true for the Range represented by the PGRange" do
@@ -453,7 +495,7 @@ describe "pg_range extension" do
     end
 
     it "should have #=== be false if the PGRange cannot be represented by a Range" do
-      @R.new(nil, nil).wont_be :===, 1.5
+      @R.new(1, 2, :exclude_begin=>true).wont_be :===, 1.5
     end
 
     it "should have #empty? indicate whether the range is empty" do
@@ -471,7 +513,6 @@ describe "pg_range extension" do
     end
 
     it "should have #to_range raise an exception if the PGRange cannot be represented by a Range" do
-      proc{@R.new(nil, 1).to_range}.must_raise(Sequel::Error)
       proc{@R.new(0, 1, :exclude_begin=>true).to_range}.must_raise(Sequel::Error)
       proc{@R.empty.to_range}.must_raise(Sequel::Error)
     end
@@ -488,6 +529,22 @@ describe "pg_range extension" do
       proc{@R.new(1, nil).to_range}.must_raise(Sequel::Error)
     end unless endless_range_support
 
+    it "should have #to_range return the represented range for startless ranges" do
+      @R.new(nil, 1).to_range.must_be :==, eval('..1')
+    end if startless_range_support
+
+    it "should have #to_range raise an exception for startless ranges" do
+      proc{@R.new(nil, 1).to_range}.must_raise(Sequel::Error)
+    end unless startless_range_support
+
+    it "should have #to_range return the represented range for startless, endless ranges" do
+      @R.new(nil, nil).to_range.must_be :==, eval('nil..nil')
+    end if startless_range_support
+
+    it "should have #to_range raise an exception for startless, endless ranges" do
+      proc{@R.new(nil, nil).to_range}.must_raise(Sequel::Error)
+    end unless startless_range_support
+
     it "should have #to_range cache the returned value" do
       @r1.to_range.must_be_same_as(@r1.to_range)
     end
@@ -507,7 +564,6 @@ describe "pg_range extension" do
     end
 
     it "should have #valid_ruby_range? return false if the PGRange cannot be represented as a Range" do
-      @R.new(nil, 1).valid_ruby_range?.must_equal false
       @R.new(0, 1, :exclude_begin=>true).valid_ruby_range?.must_equal false
       @R.empty.valid_ruby_range?.must_equal false
     end
@@ -515,5 +571,13 @@ describe "pg_range extension" do
    it "should have #valid_ruby_range return #{endless_range_support} for endless ranges" do
       @R.new(1, nil).valid_ruby_range?.must_equal(endless_range_support)
     end
+
+   it "should have #valid_ruby_range return #{startless_range_support} for endless ranges" do
+      @R.new(nil, 1).valid_ruby_range?.must_equal(startless_range_support)
+    end
+
+   it "should have #valid_ruby_range return #{startless_range_support} for startless, endless ranges" do
+      @R.new(nil, nil).valid_ruby_range?.must_equal(startless_range_support)
+    end
   end
 end

data/spec/integration/dataset_test.rb

@@ -1109,6 +1109,12 @@ describe "Sequel::Dataset#import and #multi_insert :return=>:primary_key " do
     @ds.order(:id).map([:id, :i]).must_equal [[1, 10], [2, 20], [3, 30], [4, 40], [5, 50], [6, 60]]
   end
 
+  it "should handle dataset with row_proc" do
+    ds = @ds.with_row_proc(lambda{|h| Object.new})
+    ds.multi_insert([{:i=>10}, {:i=>20}, {:i=>30}], :return=>:primary_key).must_equal [1, 2, 3]
+    ds.import([:i], [[40], [50], [60]], :return=>:primary_key).must_equal [4, 5, 6]
+  end
+  
   it "should return primary key values when :slice is used" do
     @ds.multi_insert([{:i=>10}, {:i=>20}, {:i=>30}], :return=>:primary_key, :slice=>2).must_equal [1, 2, 3]
     @ds.import([:i], [[40], [50], [60]], :return=>:primary_key, :slice=>2).must_equal [4, 5, 6]
@@ -1545,15 +1551,25 @@ describe "Sequel::Dataset DSL support" do
     @ds.exclude(:a=>[20, 10]).all.must_equal []
   end
   
-  it "should work with ranges as hash values" do
+  it "should work with endless ranges as hash values" do
     @ds.insert(20, 10)
-    @ds.filter(:a=>(10..30)).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>(25..30)).all.must_equal []
-    @ds.filter(:a=>(10..15)).all.must_equal []
-    @ds.exclude(:a=>(10..30)).all.must_equal []
-    @ds.exclude(:a=>(25..30)).all.must_equal [{:a=>20, :b=>10}]
-    @ds.exclude(:a=>(10..15)).all.must_equal [{:a=>20, :b=>10}]
-  end
+    @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('nil..nil')).all.must_equal [{:a=>20, :b=>10}]
+  end if RUBY_VERSION >= '2.7'
   
   it "should work with CASE statements" do
     @ds.insert(20, 10)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.21.0
+  version: 5.22.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-01 00:00:00.000000000 Z
+date: 2019-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -205,6 +205,7 @@ extra_rdoc_files:
 - doc/release_notes/5.19.0.txt
 - doc/release_notes/5.20.0.txt
 - doc/release_notes/5.21.0.txt
+- doc/release_notes/5.22.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -297,6 +298,7 @@ files:
 - doc/release_notes/5.2.0.txt
 - doc/release_notes/5.20.0.txt
 - doc/release_notes/5.21.0.txt
+- doc/release_notes/5.22.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt
 - doc/release_notes/5.5.0.txt