sequel 5.26.0 → 5.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c7e9baac1a3a326ffdc2506dde798441b376fecbe71594cd91efb54bc56a9a7
-  data.tar.gz: d051640fc5fb89053beaa43915eca9920222d7978be91bc704cde94f1b425532
+  metadata.gz: 512f72ad99402b33be776e759611a9299b638f49344fb1f349120c8cd1643107
+  data.tar.gz: ea0852b3ea61ef9a5a192637a2b457fe47f2374c8ee2eb20d9b02e6eb25a25ac
 SHA512:
-  metadata.gz: 0e424392185dec97acca2092fb5b3127a6619033dd62eef683f29501ece0ecacd17ada2a2b1edf27682155c6d59633fa88a475dd1ebf4bdbf8f1641f73a566a8
-  data.tar.gz: 8c1ac728b94de7b5f0cf9a3df230f35732906accea64a0b61b6eba90203e49396eacc95786ad7a78bc56b3b812cda8bd94d4e8f1d0be188b9d9ae4f49792a9de
+  metadata.gz: 4397a4a7530bd3234d7c1e3bf8b1c2b8a6845e659b86b7177dc704edf8ebf2185c499ac7ba04bb7d52006cf1367b8c0835787be1483e7bb481fa4ea2d775680b
+  data.tar.gz: 653238c46ae32bd74127bddb87dc4c99637f5eadfb7515a51e8da5bc57df10de57c2e9a97d085828cc45b97303fa66580c1c8832a5f6fbb5cdaffd585ce0ff86

data/CHANGELOG

@@ -1,3 +1,15 @@
+=== 5.27.0 (2019-12-01)
+
+* Add Sequel::DEFAULT for a DEFAULT expression, useful for assigning to default values (jeremyevans)
+
+* Make Postgres::ArrayOp#join in pg_array_ops extension work correctly on PostgreSQL <9.1 (jeremyevans)
+
+* Make pg_enum extension work correctly on PostgreSQL 8.3-9.0 (jeremyevans)
+
+* Emulate FILTER clause for aggregate functions using CASE on databases not supporting it directly (jeremyevans)
+
+* Support ordering by NULLS FIRST/NULLS LAST without emulation on SQLite 3.30+ (jeremyevans)
+
 === 5.26.0 (2019-11-01)
 
 * Recognize two additional foreign key constraint violation codes on MySQL 8.0.13+ (rianmcguire) (#1657)

data/doc/release_notes/5.27.0.txt

@@ -0,0 +1,21 @@
+= New Features
+
+* Sequel::DEFAULT has been added a constant for the DEFAULT expression,
+  useful in inserts and especially updates:
+
+    DB[:a].where(:id=>1).update(:b=>Sequel::DEFAULT)
+    # UPDATE "a" SET "b" = DEFAULT WHERE "id" = 1
+
+* SQL::Function#filter for filtered aggregate functions is now
+  supported on all databases.  On databases not supporting it natively
+  (all except PostgreSQL 9.4+ and SQLite 3.30+), a CASE statement is
+  used to emulate the support.
+
+= Other Improvements
+
+* NULLS FIRST/LAST is now used without emulation on SQLite 3.30+.
+
+* The pg_enum extension now works correctly on PostgreSQL 8.3-9.0.
+
+* Postgres::ArrayOp#join in the pg_array_ops extension now works
+  correctly on PostgreSQL <9.1.

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

@@ -1955,6 +1955,11 @@ module Sequel
         db.server_version(@opts[:server])
       end
 
+      # PostgreSQL 9.4+ supports the FILTER clause for aggregate functions.
+      def supports_filtered_aggregates?
+        server_version >= 90400
+      end
+
       # PostgreSQL supports quoted function names.
       def supports_quoted_function_names?
         true

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

@@ -869,9 +869,9 @@ module Sequel
         end
       end
 
-      # SQLite does not natively support NULLS FIRST/LAST.
+      # SQLite supports NULLS FIRST/LAST natively in 3.30+.
       def requires_emulating_nulls_first?
-        true
+        db.sqlite_version < 33000
       end
 
       # SQLite does not support FOR UPDATE, but silently ignore it
@@ -897,6 +897,11 @@ module Sequel
         false
       end
 
+      # SQLite 3.30 supports the FILTER clause for aggregate functions.
+      def supports_filtered_aggregates?
+        db.sqlite_version >= 33000
+      end
+
       # SQLite supports quoted function names.
       def supports_quoted_function_names?
         true

data/lib/sequel/dataset/features.rb

@@ -230,6 +230,12 @@ module Sequel
       supports_cte_in_subqueries?
     end
 
+    # Whether the dataset supports the FILTER clause for aggregate functions.
+    # If not, support is emulated using CASE.
+    def supports_filtered_aggregates?
+      false
+    end
+
     # Whether the database supports quoting function names.
     def supports_quoted_function_names?
       false

data/lib/sequel/dataset/sql.rb

@@ -492,11 +492,24 @@ module Sequel
       end
 
       sql << '('
+      if filter = opts[:filter]
+        filter = filter_expr(filter, &opts[:filter_block])
+      end
       if opts[:*]
-        sql << '*'
+        if filter && !supports_filtered_aggregates?
+          literal_append(sql, Sequel.case({filter=>1}, nil))
+          filter = nil
+        else
+          sql <<  '*'
+        end
       else
         sql << "DISTINCT " if opts[:distinct]
-        expression_list_append(sql, f.args)
+        if filter && !supports_filtered_aggregates?
+          expression_list_append(sql, f.args.map{|arg| Sequel.case({filter=>arg}, nil)})
+          filter = nil
+        else
+          expression_list_append(sql, f.args)
+        end
         if order = opts[:order]
           sql << " ORDER BY "
           expression_list_append(sql, order)
@@ -510,9 +523,9 @@ module Sequel
         sql << ')'
       end
 
-      if filter = opts[:filter]
+      if filter
         sql << " FILTER (WHERE "
-        literal_append(sql, filter_expr(filter, &opts[:filter_block]))
+        literal_append(sql, filter)
         sql << ')'
       end
 

data/lib/sequel/extensions/pg_array_ops.rb

@@ -51,8 +51,8 @@
 #   ia.length(2)       # array_length(int_array_column, 2)
 #   ia.lower           # array_lower(int_array_column, 1)
 #   ia.lower(2)        # array_lower(int_array_column, 2)
-#   ia.join            # array_to_string(int_array_column, '', NULL)
-#   ia.join(':')       # array_to_string(int_array_column, ':', NULL)
+#   ia.join            # array_to_string(int_array_column, '')
+#   ia.join(':')       # array_to_string(int_array_column, ':')
 #   ia.join(':', ' ')  # array_to_string(int_array_column, ':', ' ')
 #   ia.unnest          # unnest(int_array_column)
 #   ia.unnest(:b)      # unnest(int_array_column, b)
@@ -217,12 +217,16 @@ module Sequel
 
       # Call the array_to_string method:
       #
-      #   array_op.join           # array_to_string(array, '', NULL)
-      #   array_op.to_string      # array_to_string(array, '', NULL)
-      #   array_op.join(":")      # array_to_string(array, ':', NULL)
+      #   array_op.join           # array_to_string(array, '')
+      #   array_op.to_string      # array_to_string(array, '')
+      #   array_op.join(":")      # array_to_string(array, ':')
       #   array_op.join(":", "*") # array_to_string(array, ':', '*')
       def to_string(joiner="", null=nil)
-        function(:array_to_string, joiner, null)
+        if null.nil?
+          function(:array_to_string, joiner)
+        else
+          function(:array_to_string, joiner, null)
+        end
       end
       alias join to_string
       

data/lib/sequel/extensions/pg_enum.rb

@@ -133,8 +133,11 @@ module Sequel
       # the pg_type table to get names and array oids for
       # enums.
       def parse_enum_labels
+        order = [:enumtypid]
+        order << :enumsortorder if server_version >= 90100
+
         enum_labels = metadata_dataset.from(:pg_enum).
-          order(:enumtypid, :enumsortorder).
+          order(*order).
           select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel).freeze
         enum_labels.each_value(&:freeze)
 

data/lib/sequel/sql.rb

@@ -1317,6 +1317,7 @@ module Sequel
       CURRENT_DATE = Constant.new(:CURRENT_DATE)
       CURRENT_TIME = Constant.new(:CURRENT_TIME)
       CURRENT_TIMESTAMP = Constant.new(:CURRENT_TIMESTAMP)
+      DEFAULT = Constant.new(:DEFAULT)
       SQLTRUE = TRUE = BooleanConstant.new(true)
       SQLFALSE = FALSE = BooleanConstant.new(false)
       NULL = BooleanConstant.new(nil)

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

data/spec/adapters/postgres_spec.rb

@@ -70,7 +70,7 @@ describe "PostgreSQL", '#create_table' do
 
   it "should create an unlogged table" do
     @db.create_table(:unlogged_dolls, :unlogged => true){text :name}
-  end
+  end if DB.server_version >= 90100
 
   it "should create a table inheriting from another table" do
     @db.create_table(:unlogged_dolls){text :name}
@@ -615,10 +615,6 @@ describe "A PostgreSQL dataset" do
     @d.from{generate_series(1,3,1).as(:a)}.select{(a.sql_number % 2).as(:a)}.from_self.get{mode.function.within_group(:a)}.must_equal 1
   end if DB.server_version >= 90400
 
-  it "should support filtered aggregate functions" do
-    @d.from{generate_series(1,3,1).as(:a)}.select{(a.sql_number % 2).as(:a)}.from_self.get{count(:a).filter(:a=>1)}.must_equal 2
-  end if DB.server_version >= 90400
-
   it "should support functions with ordinality" do
     @d.from{generate_series(1,10,3).with_ordinality}.select_map([:generate_series, :ordinality]).must_equal [[1, 1], [4, 2], [7, 3], [10, 4]]
   end if DB.server_version >= 90400
@@ -1272,7 +1268,7 @@ describe "A PostgreSQL database" do
   end
 
   it "should support indexes with index type" do
-    @db.create_table(:posts){point :p; index :p, :type => 'gist'}
+    @db.create_table(:posts){box :geom; index :geom, :type => 'gist'}
   end
 
   it "should support unique indexes with index type" do
@@ -2704,6 +2700,8 @@ describe 'PostgreSQL array handling' do
     if @db.server_version >= 90000
       @ds.get(Sequel.pg_array(:i5).join).must_equal '15'
       @ds.get(Sequel.pg_array(:i5).join(':')).must_equal '1:5'
+    end
+    if @db.server_version >= 90100
       @ds.get(Sequel.pg_array(:i5).join(':', '*')).must_equal '1:*:5'
     end
     if @db.server_version >= 90300
@@ -4475,4 +4473,4 @@ describe "pg_auto_constraint_validations plugin" do
       File.delete(cache_file) if File.file?(cache_file)
     end
   end
-end if DB.respond_to?(:error_info)
+end if DB.respond_to?(:error_info) && DB.server_version >= 90300

data/spec/adapters/sqlite_spec.rb

@@ -623,7 +623,7 @@ describe "SQLite", 'INSERT ON CONFLICT' do
     @ds.insert_conflict(:target=>:a).insert(1, 3, 4, false)
     @ds.insert_conflict(:target=>:c, :conflict_where=>:c_is_unique).insert(11, 12, 3, true)
     @ds.all.must_equal [{:a=>1, :b=>2, :c=>3, :c_is_unique=>false}, {:a=>10, :b=>11, :c=>3, :c_is_unique=>true}]
-  end
+  end unless DB.adapter_scheme == :amalgalite
 
   it "Dataset#insert_ignore and insert_conflict should work with multi_insert/import" do
     @ds.insert(1, 2, 3, false)

data/spec/core/expression_filters_spec.rb

@@ -353,6 +353,11 @@ describe "Blockless Ruby Filters" do
     @d.l({:x => Sequel::FALSE}).must_equal '(x IS FALSE)'
     @d.l({:x => Sequel::SQLTRUE}).must_equal '(x IS TRUE)'
     @d.l({:x => Sequel::SQLFALSE}).must_equal '(x IS FALSE)'
+
+    @d.l({:x => Sequel::CURRENT_DATE}).must_equal '(x = CURRENT_DATE)'
+    @d.l({:x => Sequel::CURRENT_TIME}).must_equal '(x = CURRENT_TIME)'
+    @d.l({:x => Sequel::CURRENT_TIMESTAMP}).must_equal '(x = CURRENT_TIMESTAMP)'
+    @d.l({:x => Sequel::DEFAULT}).must_equal '(x = DEFAULT)'
   end
   
   it "should support negation of SQL::Constants" do
@@ -741,14 +746,23 @@ describe Sequel::SQL::VirtualRow do
     @d.l{mode.function.within_group(:a, :b)}.must_equal 'mode() WITHIN GROUP (ORDER BY "a", "b")' 
   end
 
+  it "should handle emualted filtered aggregate function calls" do
+    @d.l{count.function.*.filter(Sequel.&(:a, :b))}.must_equal 'count((CASE WHEN ("a" AND "b") THEN 1 ELSE NULL END))' 
+    @d.l{count.function.*.filter(:a=>1)}.must_equal 'count((CASE WHEN ("a" = 1) THEN 1 ELSE NULL END))'
+    @d.l{count(:a).filter{b > 1}}.must_equal 'count((CASE WHEN ("b" > 1) THEN "a" ELSE NULL END))'
+    @d.l{count(:a).filter(:a=>1){b > 1}}.must_equal 'count((CASE WHEN (("a" = 1) AND ("b" > 1)) THEN "a" ELSE NULL END))'
+  end
+
   it "should handle filtered aggregate function calls" do
+    @d = @d.with_extend{def supports_filtered_aggregates?; true end}
     @d.l{count.function.*.filter(Sequel.&(:a, :b))}.must_equal 'count(*) FILTER (WHERE ("a" AND "b"))' 
     @d.l{count.function.*.filter(:a=>1)}.must_equal 'count(*) FILTER (WHERE ("a" = 1))'
     @d.l{count.function.*.filter{b > 1}}.must_equal 'count(*) FILTER (WHERE ("b" > 1))'
     @d.l{count.function.*.filter(:a=>1){b > 1}}.must_equal 'count(*) FILTER (WHERE (("a" = 1) AND ("b" > 1)))'
   end
 
-  it "should handle fitlered ordered-set and hypothetical-set function calls" do
+  it "should handle filtered ordered-set and hypothetical-set function calls" do
+    @d = @d.with_extend{def supports_filtered_aggregates?; true end}
     @d.l{mode.function.within_group(:a).filter(:a=>1)}.must_equal 'mode() WITHIN GROUP (ORDER BY "a") FILTER (WHERE ("a" = 1))' 
   end
 

data/spec/extensions/pg_array_ops_spec.rb

@@ -83,9 +83,9 @@ describe "Sequel::Postgres::ArrayOp" do
   end
 
   it "#to_string/join should use the array_to_string function" do
-    @db.literal(@a.to_string).must_equal "array_to_string(a, '', NULL)"
-    @db.literal(@a.join).must_equal "array_to_string(a, '', NULL)"
-    @db.literal(@a.join(':')).must_equal "array_to_string(a, ':', NULL)"
+    @db.literal(@a.to_string).must_equal "array_to_string(a, '')"
+    @db.literal(@a.join).must_equal "array_to_string(a, '')"
+    @db.literal(@a.join(':')).must_equal "array_to_string(a, ':')"
     @db.literal(@a.join(':', '*')).must_equal "array_to_string(a, ':', '*')"
   end
 

data/spec/integration/dataset_test.rb

@@ -92,6 +92,17 @@ describe "Simple Dataset operations" do
     @ds.from_self(:alias=>:items).graph(@ds.from_self, {:id=>:id}, :table_alias=>:b).extension(:graph_each).all.must_equal [{:items=>{:id=>1, :number=>10}, :b=>{:id=>1, :number=>10}}]
   end
 
+  cspecify "should have insert and update work with Sequel::DEFAULT", :sqlite do
+    @db.create_table!(:items) do
+      Integer :number, :default=>10
+    end
+    @ds.insert(:number=>Sequel::DEFAULT)
+    @ds.select_map(:number).must_equal [10]
+    @ds.insert(:number=>20)
+    @ds.update(:number=>Sequel::DEFAULT)
+    @ds.select_map(:number).must_equal [10, 10]
+  end
+
   cspecify "should have insert work correctly when inserting a row with all NULL values", :hsqldb do
     @db.create_table!(:items) do
       String :name
@@ -443,6 +454,20 @@ describe Sequel::Dataset do
     @d.extension(:sequel_4_dataset_methods).interval(:value).to_i.must_equal 6
   end
 
+  it "should support or emulate filtered aggregate functions" do
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 324)
+    @d.get{count.function.*.filter{value > 100}}.must_equal 3
+    @d.get{count.function.*.filter{value > 200}}.must_equal 2
+    @d.get{count.function.*.filter{value > 400}}.must_equal 1
+    @d.get{count.function.*.filter{value > 500}}.must_equal 0
+    @d.get{count(:value).filter{value > 100}}.must_equal 3
+    @d.get{count(:value).filter{value > 200}}.must_equal 2
+    @d.get{count(:value).filter{value > 400}}.must_equal 1
+    @d.get{count(:value).filter{value > 500}}.must_equal 0
+  end
+
   it "should return the correct records" do
     @d.to_a.must_equal []
     @d.insert(:name => 'abc', :value => 123)

data/spec/integration/plugin_test.rb

@@ -2393,7 +2393,7 @@ describe "string_agg extension" do
   cspecify "should have string_agg return aggregated concatenation for distinct values", :mssql, :sqlite, :oracle, :db2, :derby do
     @ds.select_group(:id).select_append(Sequel.string_agg(:s).order(:s).distinct.as(:v)).map([:id, :v]).must_equal [[1, 'a,b,c'], [2, 'aa,bb']]
   end
-end
+end if (DB.database_type != :postgres || DB.server_version >= 90000)
 
 describe "insert_conflict plugin" do
   before(:all) do

data/spec/integration/spec_helper.rb

@@ -62,4 +62,10 @@ if ENV['SEQUEL_FREEZE_DATABASE']
   DB.freeze
 end
 
-puts "running #{defined?(SEQUEL_ADAPTER_TEST) ? SEQUEL_ADAPTER_TEST : "integration (database type: #{DB.database_type})"} specs on #{RUBY_ENGINE} #{defined?(JRUBY_VERSION) ? JRUBY_VERSION : RUBY_VERSION} with #{DB.adapter_scheme} adapter"
+version = if DB.respond_to?(:server_version)
+  DB.server_version
+elsif DB.respond_to?(:sqlite_version)
+  DB.sqlite_version
+end
+
+puts "running #{defined?(SEQUEL_ADAPTER_TEST) ? SEQUEL_ADAPTER_TEST : "integration (database type: #{DB.database_type})"} specs on #{RUBY_ENGINE} #{defined?(JRUBY_VERSION) ? JRUBY_VERSION : RUBY_VERSION} with #{DB.adapter_scheme} adapter#{" (database version: #{version})" if version}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.26.0
+  version: 5.27.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-01 00:00:00.000000000 Z
+date: 2019-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -224,6 +224,7 @@ extra_rdoc_files:
 - doc/release_notes/5.24.0.txt
 - doc/release_notes/5.25.0.txt
 - doc/release_notes/5.26.0.txt
+- doc/release_notes/5.27.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -321,6 +322,7 @@ files:
 - doc/release_notes/5.24.0.txt
 - 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.3.0.txt
 - doc/release_notes/5.4.0.txt
 - doc/release_notes/5.5.0.txt