sequel 5.22.0 → 5.27.0

data/lib/sequel/extensions/pg_array.rb

@@ -340,14 +340,18 @@ module Sequel
             raise Sequel::Error, "invalid array, empty string" if eos?
             raise Sequel::Error, "invalid array, doesn't start with {" unless scan(/((\[\d+:\d+\])+=)?\{/)
 
+            # :nocov:
             while !eos?
+            # :nocov:
               char = scan(/[{}",]|[^{}",]+/)
               if char == ','
                 # Comma outside quoted string indicates end of current entry
                 new_entry
               elsif char == '"'
                 raise Sequel::Error, "invalid array, opening quote with existing recorded data" unless @recorded.empty?
+                # :nocov:
                 while true
+                # :nocov:
                   char = scan(/["\\]|[^"\\]+/)
                   if char == '\\'
                     @recorded << getch

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/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:
 #
@@ -208,11 +208,19 @@ module Sequel
     JSONB_PRIMITIVE_WRAPPER_MAPPING.freeze
 
     JSON_COMBINED_WRAPPER_MAPPING =JSON_WRAPPER_MAPPING.merge(JSON_PRIMITIVE_WRAPPER_MAPPING).freeze
-    JSON_WRAP_CLASSES = JSON_COMBINED_WRAPPER_MAPPING.keys.freeze
-
     JSONB_COMBINED_WRAPPER_MAPPING =JSONB_WRAPPER_MAPPING.merge(JSONB_PRIMITIVE_WRAPPER_MAPPING).freeze
     JSONB_WRAP_CLASSES = JSONB_COMBINED_WRAPPER_MAPPING.keys.freeze
 
+    Sequel::Deprecation.deprecate_constant(self, :JSON_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSONB_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSON_PRIMITIVE_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSONB_PRIMITIVE_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSON_COMBINED_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSONB_COMBINED_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSONB_WRAP_CLASSES)
+
+    JSON_WRAP_CLASSES = [Hash, Array, String, Integer, Float, NilClass, TrueClass, FalseClass].freeze
+
     # Methods enabling Database object integration with the json type.
     module JSONDatabaseMethods
       def self.extended(db)
@@ -228,6 +236,69 @@ module Sequel
         end
       end
 
+      # Return the wrapper class for the json type if value is Hash or Array.
+      def self.json_wrapper(value)
+        case value
+        when ::Hash
+          JSONHash
+        when ::Array
+          JSONArray
+        end
+      end
+
+      # Return the wrapper class for the jsonb type if value is Hash or Array.
+      def self.jsonb_wrapper(value)
+        case value
+        when ::Hash
+          JSONBHash
+        when ::Array
+          JSONBArray
+        end
+      end
+
+      # Return the wrapper class for the json type if value is a supported type.
+      def self.json_primitive_wrapper(value)
+        case value
+        when ::Hash
+          JSONHash
+        when ::Array
+          JSONArray
+        when ::String
+          JSONString
+        when ::Integer
+          JSONInteger
+        when ::Float
+          JSONFloat
+        when ::NilClass
+          JSONNull
+        when ::TrueClass
+          JSONTrue
+        when ::FalseClass
+          JSONFalse
+        end
+      end
+
+      # Return the wrapper class for the jsonb type if value is a supported type.
+      def self.jsonb_primitive_wrapper(value)
+        case value
+        when ::Hash
+          JSONBHash
+        when ::Array
+          JSONBArray
+        when ::String
+          JSONBString
+        when ::Integer
+          JSONBInteger
+        when ::Float
+          JSONBFloat
+        when ::NilClass
+          JSONBNull
+        when ::TrueClass
+          JSONBTrue
+        when ::FalseClass
+          JSONBFalse
+        end
+      end
 
       # Deprecated
       def self.db_parse_json(s)
@@ -326,9 +397,9 @@ module Sequel
       # Wrap the parsed JSON value in the appropriate JSON wrapper class.
       # Only wrap primitive values if wrap_json_primitives is set.
       def _wrap_json(value)
-        if klass = JSON_WRAPPER_MAPPING[value.class]
+        if klass = JSONDatabaseMethods.json_wrapper(value)
           klass.new(value)
-        elsif klass = JSON_PRIMITIVE_WRAPPER_MAPPING[value.class]
+        elsif klass = JSONDatabaseMethods.json_primitive_wrapper(value)
           if wrap_json_primitives
             klass.new(value)
           else
@@ -342,9 +413,9 @@ module Sequel
       # Wrap the parsed JSON value in the appropriate JSONB wrapper class.
       # Only wrap primitive values if wrap_json_primitives is set.
       def _wrap_jsonb(value)
-        if klass = JSONB_WRAPPER_MAPPING[value.class]
+        if klass = JSONDatabaseMethods.jsonb_wrapper(value)
           klass.new(value)
-        elsif klass = JSONB_PRIMITIVE_WRAPPER_MAPPING[value.class]
+        elsif klass = JSONDatabaseMethods.jsonb_primitive_wrapper(value)
           if wrap_json_primitives
             klass.new(value)
           else
@@ -413,10 +484,10 @@ module Sequel
             _wrap_json(_parse_json(value))
           end
         when *JSON_WRAP_CLASSES
-          JSON_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+          JSONDatabaseMethods.json_primitive_wrapper(value).new(value)
         when JSONBObject
           value = value.__getobj__
-          JSON_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+          JSONDatabaseMethods.json_primitive_wrapper(value).new(value)
         else
           raise Sequel::InvalidValue, "invalid value for json: #{value.inspect}"
         end
@@ -433,11 +504,11 @@ module Sequel
           else
             _wrap_jsonb(_parse_json(value))
           end
-        when *JSONB_WRAP_CLASSES
-          JSONB_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+        when *JSON_WRAP_CLASSES
+          JSONDatabaseMethods.jsonb_primitive_wrapper(value).new(value)
         when JSONObject
           value = value.__getobj__
-          JSONB_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+          JSONDatabaseMethods.jsonb_primitive_wrapper(value).new(value)
         else
           raise Sequel::InvalidValue, "invalid value for jsonb: #{value.inspect}"
         end
@@ -460,7 +531,7 @@ module Sequel
         Postgres::JSONHash.new(v)
       when Postgres::JSONBObject
         v = v.__getobj__
-        Postgres::JSON_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+        Postgres::JSONDatabaseMethods.json_primitive_wrapper(v).new(v)
       else
         Sequel.pg_json_op(v)
       end
@@ -472,7 +543,7 @@ module Sequel
     def pg_json_wrap(v)
       case v
       when *Postgres::JSON_WRAP_CLASSES
-        Postgres::JSON_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+        Postgres::JSONDatabaseMethods.json_primitive_wrapper(v).new(v)
       else
         raise Error, "invalid value passed to Sequel.pg_json_wrap: #{v.inspect}"
       end
@@ -492,7 +563,7 @@ module Sequel
         Postgres::JSONBHash.new(v)
       when Postgres::JSONObject
         v = v.__getobj__
-        Postgres::JSONB_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+        Postgres::JSONDatabaseMethods.jsonb_primitive_wrapper(v).new(v)
       else
         Sequel.pg_jsonb_op(v)
       end
@@ -503,8 +574,8 @@ module Sequel
     # other types.
     def pg_jsonb_wrap(v)
       case v
-      when *Postgres::JSONB_WRAP_CLASSES
-        Postgres::JSONB_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+      when *Postgres::JSON_WRAP_CLASSES
+        Postgres::JSONDatabaseMethods.jsonb_primitive_wrapper(v).new(v)
       else
         raise Error, "invalid value passed to Sequel.pg_jsonb_wrap: #{v.inspect}"
       end

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/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
@@ -228,7 +228,9 @@ module Sequel
           if skip(/\)/)
             values << nil
           else
+            # :nocov:
             until eos?
+            # :nocov:
               if skip(/"/)
                 values << scan(/(\\.|""|[^"])*/).gsub(/\\(.)|"(")/, '\1\2')
                 skip(/"[,)]/)

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