sequel 5.25.0 → 5.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a91737db8ac64d56de1b6ac6ffcd48c657b3e52cd42c310872ed7935cf1ef24
-  data.tar.gz: c650010eaa68c3f0b086ad9d283e363c30d2c4667ffe8d660801f3d65e06f243
+  metadata.gz: 8c7e9baac1a3a326ffdc2506dde798441b376fecbe71594cd91efb54bc56a9a7
+  data.tar.gz: d051640fc5fb89053beaa43915eca9920222d7978be91bc704cde94f1b425532
 SHA512:
-  metadata.gz: 6779429490fea9527a7b920616db24bbd10f5daab731516b396053cd9626a3b9d44413b337576c1bffa0f04e511fa090ef536b270bddc3931b88519224514596
-  data.tar.gz: c0376415c7a8eafe79ceadc66940944d64e9261209738905790cdd8821c377eea31270026730a2cb4a17adce921c60f5519591c31fb4d62250328bb085b5cfaa
+  metadata.gz: 0e424392185dec97acca2092fb5b3127a6619033dd62eef683f29501ece0ecacd17ada2a2b1edf27682155c6d59633fa88a475dd1ebf4bdbf8f1641f73a566a8
+  data.tar.gz: 8c1ac728b94de7b5f0cf9a3df230f35732906accea64a0b61b6eba90203e49396eacc95786ad7a78bc56b3b812cda8bd94d4e8f1d0be188b9d9ae4f49792a9de

data/CHANGELOG

@@ -1,3 +1,17 @@
+=== 5.26.0 (2019-11-01)
+
+* Recognize two additional foreign key constraint violation codes on MySQL 8.0.13+ (rianmcguire) (#1657)
+
+* Support table aliases for single-table INSERT statements on PostgreSQL 9.5+ (jeremyevans) (#1656)
+
+* Implement Sequel::Postgres::PGRange#hash so instances work correctly in hashes (jeremyevans) (#1648)
+
+* Make dirty plugin work correctly with typecast_on_load plugin (jeremyevans) (#1647)
+
+* Add support for :require_modification option when setting up nested_attributes (jeremyevans)
+
+* Add support for SQL/JSON path expressions to the pg_json_ops extension, supported by PostgreSQL 12+ (jeremyevans)
+
 === 5.25.0 (2019-10-01)
 
 * Fix Sequel::SQL::NumericMethods#coerce to not raise NoMethodError if super method is not defined (jeremyevans) (#1645)

data/README.rdoc

@@ -578,7 +578,7 @@ A single model instance can also be fetched by specifying a condition:
   post = Post.first(title: 'hello world')
   post = Post.first{num_comments < 10}
 
-The dataset for a model class returns rows a model instances instead of plain hashes:
+The dataset for a model class returns rows of model instances instead of plain hashes:
 
   DB[:posts].first.class # => Hash
   Post.first.class # => Post

data/doc/postgresql.rdoc

@@ -341,12 +341,12 @@ Dataset#overriding_system_value and Dataset#overriding_user_value to use this ne
 syntax:
 
   DB.create_table(:table){primary_key :id}
-  # Ignore the given value for id, using the identity's sequence value
+  # Ignore the given value for id, using the identity's sequence value.
   DB[:table].overriding_user_value.insert(:id=>1)
 
   DB.create_table(:table){primary_key :id, :identity=>:always}
   # Force the use of the given value for id, because otherwise the insert will
-  # raise an error, since GENERATED ALWAYS was using when creating the column.
+  # raise an error, since GENERATED ALWAYS was used when creating the column.
   DB[:table].overriding_system_value.insert(:id=>1)
 
 === Distinct On Specific Columns

data/doc/release_notes/5.26.0.txt

@@ -0,0 +1,35 @@
+= New Features
+
+* Support for SQL/JSON path expressions has been added to the
+  pg_json_ops extension. These are supported in PostgreSQL 12+.
+  Examples:
+
+    j = Sequel.pg_json_op(:json_column)
+    j.path_exists('$.foo')      # (jsonb_column @? '$.foo')
+    j.path_match('$.foo')       # (jsonb_column @@ '$.foo')
+    j.path_exists!('$.foo')     # jsonb_path_exists(jsonb_column, '$.foo')
+    j.path_match!('$.foo')      # jsonb_path_match(jsonb_column, '$.foo')
+    j.path_query('$.foo')       # jsonb_path_query(jsonb_column, '$.foo')
+    j.path_query_array('$.foo') # jsonb_path_query_array(jsonb_column, '$.foo')
+    j.path_query_first('$.foo') # jsonb_path_query_first(jsonb_column, '$.foo')
+
+* The nested_attributes method in the nested_attributes plugin now
+  supports a :require_modification option, which can override the
+  default require_modification setting for the nested objects. This
+  can be useful to avoid errors if multiple requests are submitted
+  simultaneously to delete the same nested row.
+
+= Other Improvements
+
+* The dirty plugin now works correctly with the typecast_on_load
+  plugin.
+
+* Sequel::Postgres::PGRange#hash has been added to the pg_range
+  extension, allowing PGRange instances to be usable as hash keys.
+
+* Table aliases are now supported for single table INSERT
+  statements on PostgreSQL 9.5+, which can make some insert_conflict
+  usage easier.
+
+* Two more foreign key constraint violation types are now recognized
+  on MySQL 8.0.13+.

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

@@ -1806,6 +1806,16 @@ module Sequel
         end
       end
 
+      # Include aliases when inserting into a single table on PostgreSQL 9.5+.
+      def insert_into_sql(sql)
+        sql << " INTO "
+        if (f = @opts[:from]) && f.length == 1
+          identifier_append(sql, server_version >= 90500 ? f.first : unaliased_identifier(f.first))
+        else
+          source_list_append(sql, f)
+        end
+      end
+
       # Return the primary key to use for RETURNING in an INSERT statement
       def insert_pk
         if (f = opts[:from]) && !f.empty?

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -55,7 +55,7 @@ module Sequel
             NotNullConstraintViolation
           when 1062
             UniqueConstraintViolation
-          when 1451, 1452
+          when 1451, 1452, 1216, 1217
             ForeignKeyConstraintViolation
           when 4025
             CheckConstraintViolation

data/lib/sequel/extensions/pg_json.rb

@@ -12,7 +12,7 @@
 #
 # Note that wrapping JSON primitives changes the behavior for
 # JSON false and null values.  Because only +false+ and +nil+
-# in Ruby are considered falesy, wrapping these objects results
+# in Ruby are considered falsey, wrapping these objects results
 # in unexpected behavior if you use the values directly in
 # conditionals:
 #

data/lib/sequel/extensions/pg_json_ops.rb

@@ -73,6 +73,23 @@
 #   j.pretty                  # jsonb_pretty(jsonb_column)
 #   j.set(%w'0 a', :h)        # jsonb_set(jsonb_column, ARRAY['0','a'], h, true)
 #
+# On PostgreSQL 12+ SQL/JSON functions and operators are supported:
+#
+#   j.path_exists('$.foo')      # (jsonb_column @? '$.foo')
+#   j.path_match('$.foo')       # (jsonb_column @@ '$.foo')
+#
+#   j.path_exists!('$.foo')     # jsonb_path_exists(jsonb_column, '$.foo')
+#   j.path_match!('$.foo')      # jsonb_path_match(jsonb_column, '$.foo')
+#   j.path_query('$.foo')       # jsonb_path_query(jsonb_column, '$.foo')
+#   j.path_query_array('$.foo') # jsonb_path_query_array(jsonb_column, '$.foo')
+#   j.path_query_first('$.foo') # jsonb_path_query_first(jsonb_column, '$.foo')
+#
+# For the PostgreSQL 12+ SQL/JSON functions, one argument is required (+path+) and
+# two more arguments are optional (+vars+ and +silent+).  +path+ specifies the JSON path.
+# +vars+ specifies a hash or a string in JSON format of named variables to be
+# substituted in +path+. +silent+ specifies whether errors are suppressed. By default,
+# errors are not suppressed.
+#
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
 # JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
@@ -292,6 +309,8 @@ module Sequel
       CONTAINED_BY = ["(".freeze, " <@ ".freeze, ")".freeze].freeze
       DELETE_PATH = ["(".freeze, " #- ".freeze, ")".freeze].freeze
       HAS_KEY = ["(".freeze, " ? ".freeze, ")".freeze].freeze
+      PATH_EXISTS = ["(".freeze, " @? ".freeze, ")".freeze].freeze
+      PATH_MATCH = ["(".freeze, " @@ ".freeze, ")".freeze].freeze
 
       # jsonb expression for deletion of the given argument from the
       # current jsonb.
@@ -362,6 +381,95 @@ module Sequel
         self.class.new(function(:insert, wrap_input_array(path), wrap_input_jsonb(other), insert_after))
       end
 
+      # Returns whether the JSON path returns any item for the json object.
+      #
+      #   json_op.path_exists("$.foo") # (json @? '$.foo')
+      def path_exists(path)
+        bool_op(PATH_EXISTS, path)
+      end
+
+      # Returns whether the JSON path returns any item for the json object.
+      #
+      #   json_op.path_exists!("$.foo")
+      #   # jsonb_path_exists(json, '$.foo')
+      #
+      #   json_op.path_exists!("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_exists(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_exists!("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_exists(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_exists!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists, path, vars, silent))
+      end
+
+      # Returns the first item of the result of JSON path predicate check for the json object.
+      # Returns nil if the first item is not true or false.
+      #
+      #   json_op.path_match("$.foo") # (json @@ '$.foo')
+      def path_match(path)
+        bool_op(PATH_MATCH, path)
+      end
+
+      # Returns the first item of the result of JSON path predicate check for the json object.
+      # Returns nil if the first item is not true or false and silent is true.
+      #
+      #   json_op.path_match!("$.foo")
+      #   # jsonb_path_match(json, '$.foo')
+      #
+      #   json_op.path_match!("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_match(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_match!("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_match(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_match!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match, path, vars, silent))
+      end
+
+      # Returns a set of all jsonb values specified by the JSON path
+      # for the json object.
+      #
+      #   json_op.path_query("$.foo")
+      #   # jsonb_path_query(json, '$.foo')
+      #
+      #   json_op.path_query("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_query(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_query("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_query(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_query(path, vars=nil, silent=nil)
+        _path_function(:jsonb_path_query, path, vars, silent)
+      end
+
+      # Returns a jsonb array of all values specified by the JSON path
+      # for the json object.
+      #
+      #   json_op.path_query_array("$.foo")
+      #   # jsonb_path_query_array(json, '$.foo')
+      #
+      #   json_op.path_query_array("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_query_array(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_query_array("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_query_array(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_query_array(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_array, path, vars, silent))
+      end
+
+      # Returns the first item of the result specified by the JSON path
+      # for the json object.
+      #
+      #   json_op.path_query_first("$.foo")
+      #   # jsonb_path_query_first(json, '$.foo')
+      #
+      #   json_op.path_query_first("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_query_first(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_query_first("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_query_first(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_query_first(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_first, path, vars, silent))
+      end
+
       # Return the receiver, since it is already a JSONBOp.
       def pg_jsonb
         self
@@ -386,6 +494,22 @@ module Sequel
 
       private
 
+      # Internals of the jsonb SQL/JSON path functions.
+      def _path_function(func, path, vars, silent)
+        args = []
+        if vars
+          if vars.is_a?(Hash)
+            vars = vars.to_json
+          end
+          args << vars
+
+          unless silent.nil?
+            args << silent
+          end
+        end
+        SQL::Function.new(func, self, path, *args)
+      end
+
       # Return a placeholder literal with the given str and args, wrapped
       # in a boolean expression, used by operators that return booleans.
       def bool_op(str, other)

data/lib/sequel/extensions/pg_range.rb

@@ -402,6 +402,15 @@ module Sequel
       end
       alias == eql?
 
+      # Make sure equal ranges have the same hash.
+      def hash
+        if @empty
+          @db_type.hash
+        else
+          [@begin, @end, @exclude_begin, @exclude_end, @db_type].hash
+        end
+      end
+
       # Allow PGRange values in case statements, where they return true if they
       # are equal to each other using eql?, or if this PGRange can be converted
       # to a Range, delegating to that range.

data/lib/sequel/extensions/sql_comments.rb

@@ -9,8 +9,8 @@
 #   #
 #
 # As you can see, this uses single line SQL comments (--) suffixed
-# by a newline.  This # plugin transforms all consecutive
-# whitespace in the comment to # a single string:
+# by a newline.  This plugin transforms all consecutive whitespace
+# in the comment to a single string:
 #
 #   ds = DB[:table].comment("Some\r\nComment     Here").all
 #   # SELECT * FROM table -- Some Comment Here

data/lib/sequel/model/base.rb

@@ -1069,7 +1069,7 @@ module Sequel
         @new = true
         @modified = true
         initialize_set(values)
-        _changed_columns.clear
+        _clear_changed_columns(:initialize)
         yield self if block_given?
       end
 
@@ -1626,6 +1626,13 @@ module Sequel
       def _changed_columns
         @changed_columns ||= []
       end
+
+      # Clear the changed columns. Reason is the reason for clearing
+      # the columns, and should be one of: :initialize, :refresh, :create
+      # or :update.
+      def _clear_changed_columns(_reason)
+        _changed_columns.clear
+      end
   
       # Do the deletion of the object's dataset, and check that the row
       # was actually deleted.
@@ -1716,7 +1723,7 @@ module Sequel
       # is used for reading newly inserted values from the database
       def _refresh(dataset)
         _refresh_set_values(_refresh_get(dataset) || raise(NoExistingObject, "Record not found"))
-        _changed_columns.clear
+        _clear_changed_columns(:refresh)
       end
 
       # Get the row of column data from the database.
@@ -1754,7 +1761,7 @@ module Sequel
               @this = nil
               @new = false
               @modified = false
-              pk ? _save_refresh : _changed_columns.clear
+              pk ? _save_refresh : _clear_changed_columns(:create)
               after_create
               true
             end
@@ -1771,7 +1778,7 @@ module Sequel
                   cc.clear
                 else
                   columns_updated = _save_update_all_columns_hash
-                  _changed_columns.clear
+                  _clear_changed_columns(:update)
                 end
               else # update only the specified columns
                 columns = Array(columns)
@@ -1798,7 +1805,7 @@ module Sequel
       # can be overridden to avoid the refresh.
       def _save_refresh
         _save_set_values(_refresh_get(this.server?(:default)) || raise(NoExistingObject, "Record not found"))
-        _changed_columns.clear
+        _clear_changed_columns(:create)
       end
 
       # Set values to the provided hash.  Called after a create,

data/lib/sequel/plugins/caching.rb

@@ -26,6 +26,9 @@ module Sequel
     # * Model.with_pk!
     # * Model.[] # when argument is not hash or nil
     # * many_to_one association method # without dynamic callback, when primary key matches
+    #
+    # You should not use this plugin if you are using sharding and there are different
+    # rows for the same primary key on different shards.
     # 
     # Usage:
     #

data/lib/sequel/plugins/csv_serializer.rb

@@ -82,9 +82,11 @@ module Sequel
           end
         END
       else
+        # :nodoc:
         def self.csv_call(*args, opts, &block)
           CSV.send(*args, opts, &block)
         end
+        # :nodoc:
       end
 
       module ClassMethods

data/lib/sequel/plugins/dirty.rb

@@ -159,9 +159,9 @@ module Sequel
 
         private
 
-        # Reset the initial values when setting values.
-        def _refresh_set_values(hash)
-          reset_initial_values
+        # Reset initial values when clearing changed columns
+        def _clear_changed_columns(reason)
+          reset_initial_values if reason == :initialize || reason == :refresh
           super
         end
 
@@ -214,12 +214,6 @@ module Sequel
           self
         end
 
-        # Reset the initial values when initializing.
-        def initialize_set(h)
-          super
-          reset_initial_values
-        end
-
         # Array holding column symbols that were not present initially.  This is necessary
         # to differentiate between values that were not present and values that were
         # present but equal to nil.

data/lib/sequel/plugins/nested_attributes.rb

@@ -113,6 +113,10 @@ module Sequel
         #               value, the attribute hash is ignored.
         # :remove :: Allow disassociation of nested records (can remove the associated
         #            object from the parent object, but not destroy the associated object).
+        # :require_modification :: Whether to require modification of nested objects when
+        #                          updating or deleting them (checking that a single row was
+        #                          updated).  By default, uses the default require_modification
+        #                          setting for the nested object.
         # :transform :: A proc to transform attribute hashes before they are
         #               passed to associated object. Takes two arguments, the parent object and
         #               the attribute hash. Uses the return value as the new attribute hash.
@@ -282,6 +286,9 @@ module Sequel
             obj = Array(public_send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
           end
           if obj
+            unless (require_modification = meta[:require_modification]).nil?
+              obj.require_modification = require_modification
+            end
             attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}
             if meta[:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
               nested_attributes_remove(meta, obj, :destroy=>true)

data/lib/sequel/plugins/typecast_on_load.rb

@@ -41,7 +41,9 @@ module Sequel
         # Typecast values using #load_typecast when the values are retrieved
         # from the database.
         def call(values)
-          super.load_typecast
+          o = super.load_typecast
+          o.send(:_clear_changed_columns, :initialize)
+          o
         end
 
         # Freeze typecast on load columns when freezing model class.
@@ -63,7 +65,6 @@ module Sequel
               set_column_value("#{c}=", v)
             end
           end
-          _changed_columns.clear
           self
         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 = 25
+  MINOR = 26
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/adapters/postgres_spec.rb

@@ -368,6 +368,14 @@ describe "PostgreSQL", 'INSERT ON CONFLICT' do
     @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>6}, :update_where=>{Sequel[:ic_test][:b]=>4}).insert(1, 3, 4).must_be_nil
     @ds.all.must_equal [{:a=>1, :b=>5, :c=>5, :c_is_unique=>false}]
   end
+
+  it "Dataset#insert_conflict should support table aliases" do
+    @ds = @db[Sequel[:ic_test].as(:foo)]
+    @ds.insert(1, 2, 5)
+    proc{@ds.insert(1, 3, 4)}.must_raise Sequel::UniqueConstraintViolation
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>Sequel[:foo][:c] + Sequel[:excluded][:c]}).insert(1, 7, 10)
+    @ds.all.must_equal [{:a=>1, :b=>15, :c=>5, :c_is_unique=>false}]
+  end
 end if DB.server_version >= 90500
 
 describe "A PostgreSQL database" do
@@ -3341,6 +3349,65 @@ describe 'PostgreSQL json type' do
       @db.from(jo.each_text).select_order_map(:key).must_equal %w'a b'
       @db.from(jo.each_text).order(:key).where(:key=>'b').get(:value).gsub(' ', '').must_match(/\{"d":\{"e":3\},"c":2\}|\{"c":2,"d":\{"e":3\}\}/)
 
+      if DB.server_version >= 120000  && json_type == :jsonb
+        @db.get(jo.path_exists('$.b.d.e')).must_equal true
+        @db.get(jo.path_exists('$.b.d.f')).must_equal false
+
+        @db.get(jo.path_exists!('$.b.d.e')).must_equal true
+        @db.get(jo.path_exists!('$.b.d.f')).must_equal false
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', '{"x":2}')).must_equal true
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', '{"x":4}')).must_equal false
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', x: 2)).must_equal true
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', x: 4)).must_equal false
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', {x: 2}, true)).must_equal true
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', {x: 4}, false)).must_equal false
+
+        @db.get(jo.path_match('$.b.d.e')).must_be_nil
+        @db.get(jo.path_match('$.b.d.f')).must_be_nil
+        @db.get(pg_json.call('b'=>{'d'=>{'e'=>true}}).op.path_match('$.b.d.e')).must_equal true
+        @db.get(pg_json.call('b'=>{'d'=>{'e'=>false}}).op.path_match('$.b.d.e')).must_equal false
+
+        proc{@db.get(jo.path_match!('$.b.d.e'))}.must_raise(Sequel::DatabaseError)
+        proc{@db.get(jo.path_match!('$.b.d.f'))}.must_raise(Sequel::DatabaseError)
+        @db.get(jo.path_match!('$.b.d.e', {}, true)).must_be_nil
+        @db.get(jo.path_match!('$.b.d.f', {}, true)).must_be_nil
+        @db.get(pg_json.call('b'=>{'d'=>{'e'=>true}}).op.path_match!('$.b.d.e')).must_equal true
+        @db.get(pg_json.call('b'=>{'d'=>{'e'=>false}}).op.path_match!('$.b.d.e')).must_equal false
+        @db.get(jo.path_match!('$.b.d.e > $x', '{"x":2}')).must_equal true
+        @db.get(jo.path_match!('$.b.d.e > $x', '{"x":4}')).must_equal false
+        @db.get(jo.path_match!('$.b.d.e > $x', x: 2)).must_equal true
+        @db.get(jo.path_match!('$.b.d.e > $x', x: 4)).must_equal false
+        @db.get(jo.path_match!('$.b.d.e > $x', {x: 2}, false)).must_equal true
+        @db.get(jo.path_match!('$.b.d.e > $x', {x: 4}, true)).must_equal false
+
+        @db.get(jo.path_query_first('$.b.d.e')).must_equal 3
+        @db.get(jo.path_query_first('$.b.d.f')).must_be_nil
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', '{"x":2}')).must_equal 3
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', '{"x":4}')).must_be_nil
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', x: 2)).must_equal 3
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', x: 4)).must_be_nil
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', {x: 2}, true)).must_equal 3
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', {x: 4}, false)).must_be_nil
+
+        @db.get(jo.path_query_array('$.b.d.e')).must_equal [3]
+        @db.get(jo.path_query_array('$.b.d.f')).must_equal []
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', '{"x":2}')).must_equal [3]
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', '{"x":4}')).must_equal []
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', x: 2)).must_equal [3]
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', x: 4)).must_equal []
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', {x: 2}, true)).must_equal [3]
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', {x: 4}, false)).must_equal []
+
+        @db.from(jo.path_query('$.b.d.e').as(:a, [:b])).get(:b).must_equal 3
+        @db.from(jo.path_query('$.b.d.f').as(:a, [:b])).get(:b).must_be_nil
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', '{"x":2}').as(:a, [:b])).get(:b).must_equal 3
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', '{"x":4}').as(:a, [:b])).get(:b).must_be_nil
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', x: 2).as(:a, [:b])).get(:b).must_equal 3
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', x: 4).as(:a, [:b])).get(:b).must_be_nil
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', {x: 2}, true).as(:a, [:b])).get(:b).must_equal 3
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', {x: 4}, false).as(:a, [:b])).get(:b).must_be_nil
+      end
+
       Sequel.extension :pg_row_ops
       @db.create_table!(:items) do
         Integer :a

data/spec/extensions/dirty_spec.rb

@@ -162,6 +162,39 @@ describe "Sequel::Plugins::Dirty" do
       @o.save
       @o.column_changes.must_equal({})
     end
+
+    it "should work with the typecast_on_load plugin" do
+      @c.instance_variable_set(:@db_schema, :initial=>{:type=>:integer})
+      @c.plugin :typecast_on_load, :initial
+      
+      @o = @c.call(:initial=>'1')
+      @o.column_changes.must_equal({})
+      @o.save
+      @o.previous_changes.must_equal({})
+    end
+
+    it "should have column_changes work with the typecast_on_load in after hooks" do
+      @c.instance_variable_set(:@db_schema, :initial=>{:type=>:integer})
+      @c.plugin :typecast_on_load, :initial
+      
+      @o = @c.new
+      @o.initial = 1
+      @o.column_changes.must_equal({:initial=>[nil, 1]})
+      column_changes_in_after_save = nil
+      @o.define_singleton_method(:after_save) do
+        column_changes_in_after_save = column_changes
+        super()
+      end
+      @db.fetch = {:initial=>1}
+      @o.save
+      column_changes_in_after_save.must_equal({:initial=>[nil, 1]})
+
+      @o.initial = 2
+      @o.column_changes.must_equal({:initial=>[1, 2]})
+      @o.save
+      column_changes_in_after_save.must_equal({:initial=>[1, 2]})
+      @o.previous_changes.must_equal({:initial=>[1, 2]})
+    end
   end
 
   describe "with existing instance" do

data/spec/extensions/nested_attributes_spec.rb

@@ -492,6 +492,54 @@ describe "NestedAttributes plugin" do
     @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 10)"]
   end
 
+  it "should raise a NoExistingObject error if object to be updated no longer exists, if the :require_modification=>true option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>true, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :name=>'L'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    proc{ar.save}.must_raise Sequel::NoExistingObject
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'L' WHERE (id = 10)"]
+  end
+
+  it "should not raise an Error if object to be updated no longer exists, if the :require_modification=>false option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>false, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :name=>'L'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    ar.save
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'L' WHERE (id = 10)"]
+  end
+
+  it "should raise a NoExistingObject error if object to be deleted no longer exists, if the :require_modification=>true option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>true, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    proc{ar.save}.must_raise Sequel::NoExistingObject
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
+  end
+
+  it "should not raise an Error if object to be deleted no longer exists, if the :require_modification=>false option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>false, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    ar.save
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
+  end
+
   it "should not attempt to validate nested attributes twice for one_to_many associations when creating them" do
     @Artist.nested_attributes :albums
     validated = []

data/spec/extensions/pg_json_ops_spec.rb

@@ -286,4 +286,71 @@ describe "Sequel::Postgres::JSONOp" do
   it "should allow transforming JSONBHash instances into ArrayOp instances" do
     @db.literal(Sequel.pg_jsonb('a'=>1).op['a']).must_equal "('{\"a\":1}'::jsonb -> 'a')"
   end
+
+  it "#path_exists should use the @? operator" do
+    @l[@jb.path_exists('$')].must_equal "(j @? '$')"
+  end
+
+  it "#path_exists result should be a boolean expression" do
+    @jb.path_exists('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_match should use the @@ operator" do
+    @l[@jb.path_match('$')].must_equal "(j @@ '$')"
+  end
+
+  it "#path_match result should be a boolean expression" do
+    @jb.path_match('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_exists! should use the jsonb_path_exists function" do
+    @l[@jb.path_exists!('$')].must_equal "jsonb_path_exists(j, '$')"
+    @l[@jb.path_exists!('$', '{"x":2}')].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}')"
+    @l[@jb.path_exists!('$', x: 2)].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}')"
+    @l[@jb.path_exists!('$', {x: 2}, true)].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_exists! result should be a boolean expression" do
+    @jb.path_exists!('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_match! should use the jsonb_path_match function" do
+    @l[@jb.path_match!('$')].must_equal "jsonb_path_match(j, '$')"
+    @l[@jb.path_match!('$', '{"x":2}')].must_equal "jsonb_path_match(j, '$', '{\"x\":2}')"
+    @l[@jb.path_match!('$', x: 2)].must_equal "jsonb_path_match(j, '$', '{\"x\":2}')"
+    @l[@jb.path_match!('$', {x: 2}, true)].must_equal "jsonb_path_match(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_match! result should be a boolean expression" do
+    @jb.path_match!('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_query should use the jsonb_path_query function" do
+    @l[@jb.path_query('$')].must_equal "jsonb_path_query(j, '$')"
+    @l[@jb.path_query('$', '{"x":2}')].must_equal "jsonb_path_query(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query('$', x: 2)].must_equal "jsonb_path_query(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query('$', {x: 2}, true)].must_equal "jsonb_path_query(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_query_array should use the jsonb_path_query_array function" do
+    @l[@jb.path_query_array('$')].must_equal "jsonb_path_query_array(j, '$')"
+    @l[@jb.path_query_array('$', '{"x":2}')].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_array('$', x: 2)].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_array('$', {x: 2}, true)].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_query_array result should be a JSONBOp" do
+    @l[@jb.path_query_array('$').path_query_array('$')].must_equal "jsonb_path_query_array(jsonb_path_query_array(j, '$'), '$')"
+  end
+
+  it "#path_query_first should use the jsonb_path_query_first function" do
+    @l[@jb.path_query_first('$')].must_equal "jsonb_path_query_first(j, '$')"
+    @l[@jb.path_query_first('$', '{"x":2}')].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_first('$', x: 2)].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_first('$', {x: 2}, true)].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_query_first result should be a JSONBOp" do
+    @l[@jb.path_query_first('$').path_query_first('$')].must_equal "jsonb_path_query_first(jsonb_path_query_first(j, '$'), '$')"
+  end
 end

data/spec/extensions/pg_range_spec.rb

@@ -136,6 +136,20 @@ describe "pg_range extension" do
     s[1][1][:ruby_default].must_equal Sequel::Postgres::PGRange.new(1, 5, :exclude_end=>true, :db_type=>'int4range')
   end
 
+  it "should work correctly in hashes" do
+    h = Hash.new(1)
+    h[@R.new(1, 2)] = 2
+    h[@R.new(nil, nil, :empty => true)] = 3
+    h[@R.new(1, 2)].must_equal 2
+    h[@R.new(1, 3)].must_equal 1
+    h[@R.new(2, 2)].must_equal 1
+    h[@R.new(1, 2, :exclude_begin => true)].must_equal 1
+    h[@R.new(1, 2, :exclude_end => true)].must_equal 1
+    h[@R.new(1, 2, :db_type => :int)].must_equal 1
+    h[@R.new(nil, nil, :empty => true)].must_equal 3
+    h[@R.new(nil, nil, :empty => true, :db_type => :int)].must_equal 1
+  end
+
   describe "database typecasting" do
     before do
       @o = @R.new(1, 2, :db_type=>'int4range')

metadata

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