sequel 5.8.0 → 5.38.0

data/lib/sequel/extensions/pg_json_ops.rb

@@ -73,6 +73,34 @@
 #   j.pretty                  # jsonb_pretty(jsonb_column)
 #   j.set(%w'0 a', :h)        # jsonb_set(jsonb_column, ARRAY['0','a'], h, true)
 #
+#   j.set_lax(%w'0 a', :h, false, 'raise_exception')
+#   # jsonb_set_lax(jsonb_column, ARRAY['0','a'], h, false, 'raise_exception')
+#
+# On PostgreSQL 12+ SQL/JSON path 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')
+#
+# On PostgreSQL 13+ timezone-aware SQL/JSON path functions and operators are supported:
+#
+#   j.path_exists_tz!('$.foo')     # jsonb_path_exists_tz(jsonb_column, '$.foo')
+#   j.path_match_tz!('$.foo')      # jsonb_path_match_tz(jsonb_column, '$.foo')
+#   j.path_query_tz('$.foo')       # jsonb_path_query_tz(jsonb_column, '$.foo')
+#   j.path_query_array_tz('$.foo') # jsonb_path_query_array_tz(jsonb_column, '$.foo')
+#   j.path_query_first_tz('$.foo') # jsonb_path_query_first_tz(jsonb_column, '$.foo')
+#
+# For the PostgreSQL 12+ SQL/JSON path 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 +320,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 +392,120 @@ 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
+
+      # The same as #path_exists!, except that timezone-aware conversions are used for date/time values.
+      def path_exists_tz!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists_tz, 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
+
+      # The same as #path_match!, except that timezone-aware conversions are used for date/time values.
+      def path_match_tz!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match_tz, 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
+
+      # The same as #path_query, except that timezone-aware conversions are used for date/time values.
+      def path_query_tz(path, vars=nil, silent=nil)
+        _path_function(:jsonb_path_query_tz, 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
+
+      # The same as #path_query_array, except that timezone-aware conversions are used for date/time values.
+      def path_query_array_tz(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_array_tz, 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
+
+      # The same as #path_query_first, except that timezone-aware conversions are used for date/time values.
+      def path_query_first_tz(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_first_tz, path, vars, silent))
+      end
+
       # Return the receiver, since it is already a JSONBOp.
       def pg_jsonb
         self
@@ -384,8 +528,30 @@ module Sequel
         self.class.new(function(:set, wrap_input_array(path), wrap_input_jsonb(other), create_missing))
       end
 
+      # The same as #set, except if +other+ is +nil+, then behaves according to +null_value_treatment+,
+      # which can be one of 'raise_exception', 'use_json_null' (default), 'delete_key', or 'return_target'.
+      def set_lax(path, other, create_missing=true, null_value_treatment='use_json_null')
+        self.class.new(function(:set_lax, wrap_input_array(path), wrap_input_jsonb(other), create_missing, null_value_treatment))
+      end
+
       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)
@@ -430,7 +596,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(JSONArray)
+    # :nocov:
       class JSONArray
         # Wrap the JSONArray instance in an JSONOp, allowing you to easily use
         # the PostgreSQL json functions and operators with literal jsons.

data/lib/sequel/extensions/pg_range.rb

@@ -158,7 +158,7 @@ module Sequel
             procs = conversion_procs
             add_conversion_proc(3908, Parser.new("tsrange", procs[1114]))
             add_conversion_proc(3910, Parser.new("tstzrange", procs[1184]))
-            if defined?(PGArray::Creator)
+            if respond_to?(:register_array_type) && defined?(PGArray::Creator)
               add_conversion_proc(3909, PGArray::Creator.new("tsrange", procs[3908]))
               add_conversion_proc(3911, PGArray::Creator.new("tstzrange", procs[3910]))
             end
@@ -215,12 +215,6 @@ module Sequel
 
           db_type = db_type.to_s.dup.freeze
 
-          if converter = opts[:converter]
-            raise Error, "can't provide both a block and :converter option to register" if block
-          else
-            converter = block
-          end
-
           if soid
             raise Error, "can't provide both a converter and :subtype_oid option to register" if has_converter 
             raise Error, "no conversion proc for :subtype_oid=>#{soid.inspect} in conversion_procs" unless converter = conversion_procs[soid]
@@ -304,6 +298,8 @@ module Sequel
       end
 
       module DatasetMethods
+        private
+
         # Handle literalization of ruby Range objects, treating them as
         # PostgreSQL ranges.
         def literal_other_append(sql, v)
@@ -402,6 +398,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.
@@ -452,13 +457,18 @@ module Sequel
         end
       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 ending") unless self.end
+        # :nocov:
+        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
+        # :nocov:
         @range = Range.new(self.begin, self.end, exclude_end?)
       end
 
@@ -466,7 +476,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 || !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/extensions/pg_range_ops.rb

@@ -116,7 +116,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(PGRange)
+    # :nocov:
       class PGRange
         # Wrap the PGRange instance in an RangeOp, allowing you to easily use
         # the PostgreSQL range functions and operators with literal ranges.

data/lib/sequel/extensions/pg_row.rb

@@ -7,7 +7,7 @@
 # that when composite fields are retrieved, they are parsed and returned
 # as instances of Sequel::Postgres::PGRow::(HashRow|ArrayRow), or
 # optionally a custom type.  HashRow and ArrayRow are DelegateClasses of
-# of Hash and Array, so they mostly act like a hash or array, but not
+# Hash and Array, so they mostly act like a hash or array, but not
 # completely (is_a?(Hash) and is_a?(Array) are false).  If you want the
 # actual hash for a HashRow, call HashRow#to_hash, and if you want the
 # actual array for an ArrayRow, call ArrayRow#to_a.  This is done so
@@ -222,13 +222,14 @@ module Sequel
         # Split the stored string into an array of strings, handling
         # the different types of quoting.
         def parse
-          return @result if @result
           values = []
           skip(/\(/)
           if skip(/\)/)
             values << nil
           else
+            # :nocov:
             until eos?
+            # :nocov:
               if skip(/"/)
                 values << scan(/(\\.|""|[^"])*/).gsub(/\\(.)|"(")/, '\1\2')
                 skip(/"[,)]/)

data/lib/sequel/extensions/pg_row_ops.rb

@@ -158,6 +158,30 @@ module Sequel
         end
       end
     end
+
+    # :nocov:
+    if defined?(PGRow::ArrayRow)
+    # :nocov:
+      class PGRow::ArrayRow
+        # Wrap the PGRow::ArrayRow instance in an PGRowOp, allowing you to easily use
+        # the PostgreSQL row functions and operators with literal rows.
+        def op
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
+
+    # :nocov:
+    if defined?(PGRow::HashRow)
+    # :nocov:
+      class PGRow::HashRow
+        # Wrap the PGRow::ArrayRow instance in an PGRowOp, allowing you to easily use
+        # the PostgreSQL row functions and operators with literal rows.
+        def op
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
   end
 
   module SQL::Builders

data/lib/sequel/extensions/pg_static_cache_updater.rb

@@ -121,7 +121,7 @@ SQL
 
         oid_map = {}
         models.each do |model|
-          raise Error, "#{model.inspect} does not use the static_cache plugin" unless model.respond_to?(:load_cache, true)
+          raise Error, "#{model.inspect} does not use the static_cache plugin" unless model.respond_to?(:load_cache)
           oid_map[get(regclass_oid(model.dataset.first_source_table))] = model
         end
 
@@ -129,7 +129,7 @@ SQL
           begin
             listen(opts[:channel_name]||default_static_cache_update_name, {:loop=>true}.merge!(opts)) do |_, _, oid|
               if model = oid_map[oid.to_i]
-                model.send(:load_cache)
+                model.load_cache
               end
             end
           ensure

data/lib/sequel/extensions/pg_timestamptz.rb

@@ -15,6 +15,8 @@
 module Sequel
   module Postgres
     module Timestamptz
+      private
+
       # Use timestamptz by default for generic timestamp value.
       def type_literal_generic_datetime(column)
         :timestamptz

data/lib/sequel/extensions/query.rb

@@ -74,6 +74,7 @@ module Sequel
         raise(Sequel::Error, "method #{method.inspect} did not return a dataset") unless @dataset.is_a?(Dataset)
         self
       end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
     end
   end
 

data/lib/sequel/extensions/run_transaction_hooks.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+#
+# The run_transaction_hooks extension allows for running after_commit or
+# after_rollback extensions before commit or rollback.  It then removes
+# the hook after running it, so it will not be run twice.
+#
+# This extension should only be used in transactional tests where the
+# transaction always rolls back, to test the behavior of the after_commit
+# and after_rollback hooks.  Any other usage is probably a bad idea.
+#
+# Example:
+#
+#   DB.extension :run_transaction_hooks
+#   x = 1
+#   DB.transaction(rollback: :always) do
+#     DB.after_rollback{x = 3}
+#     DB.after_commit{x = 2}
+#
+#     x # => 1
+#     DB.run_after_rollback_hooks
+#     x # => 3
+#     DB.run_after_commit_hooks
+#     x # => 2
+#   end
+#   x # => 2
+
+#
+class Sequel::Database
+  module RunTransactionHooks
+    # Run all savepoint and transaction after_commit hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_commit_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_commit, opts)
+    end
+
+    # Run all savepoint and transaction after_rollback hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_rollback_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_rollback, opts)
+    end
+
+    private
+
+    def _run_transaction_hooks(type, opts)
+      synchronize(opts[:server]) do |conn|
+        unless h = _trans(conn)
+          raise Sequel::Error, "Cannot call run_#{type}_hooks outside of a transaction"
+        end
+
+        if hooks = h[type]
+          hooks.each(&:call)
+          hooks.clear
+        end
+
+        if (savepoints = h[:savepoints])
+          savepoints.each do |savepoint|
+            if hooks = savepoint[type]
+              hooks.each(&:call)
+              hooks.clear
+            end
+          end
+        end
+      end
+    end
+  end
+
+  register_extension(:run_transaction_hooks, RunTransactionHooks)
+end