sequel 5.22.0 → 5.26.0

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

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/association_multi_add_remove.rb

@@ -0,0 +1,83 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The association_multi_add_remove plugin allows adding, removing and setting
+    # multiple associated objects in a single method call.
+    # By default Sequel::Model defines singular <tt>add_*</tt> and <tt>remove_*</tt>
+    # methods that operate on a single associated object, this adds plural forms
+    # that operate on multiple associated objects. Example:
+    #
+    #   artist.albums # => [album1]
+    #   artist.add_albums([album2, album3])
+    #   artist.albums # => [album1, album2, album3]
+    #   artist.remove_albums([album3, album1])
+    #   artist.albums # => [album2]
+    #   artist.albums = [album2, album3]
+    #   artist.albums # => [album2, album3]
+    #
+    # It can handle all situations that the normal singular methods handle, but there is
+    # no attempt to optimize behavior, so using these methods will not improve performance.
+    #
+    # The add/remove/set methods defined by this plugin use a transaction,
+    # so if one add/remove/set fails and raises an exception, all adds/removes/set
+    # will be rolled back. If you are using database sharding and want to save
+    # to a specific shard, call Model#set_server to set the server for this instance,
+    # as the transaction will be opened on that server.
+    #
+    # You can customize the method names used for adding/removing multiple associated
+    # objects using the :multi_add_method and :multi_remove_method association options.
+    #
+    # Usage:
+    #
+    #   # Allow adding/removing/setting multiple associated objects in a single call
+    #   # for all model subclass instances (called before loading subclasses):
+    #   Sequel::Model.plugin :association_multi_add_remove
+    #
+    #   # Allow adding/removing/setting multiple associated objects in a single call
+    #   # for Album instances (called before defining associations in the class):
+    #   Album.plugin :association_multi_add_remove
+    module AssociationMultiAddRemove
+      module ClassMethods
+        # Define the methods use to add/remove/set multiple associated objects
+        # in a single method call.
+        def def_association_instance_methods(opts)
+          super
+
+          if opts[:adder]
+            add_method = opts[:add_method]
+            multi_add_method = opts[:multi_add_method] || :"add_#{opts[:name]}"
+            multi_add_method = nil if add_method == multi_add_method
+            if multi_add_method
+              association_module_def(multi_add_method, opts) do |objs, *args|
+                db.transaction(:server=>@server){objs.map{|obj| send(add_method, obj, *args)}.compact}
+              end
+            end
+          end
+
+          if opts[:remover]
+            remove_method = opts[:remove_method]
+            multi_remove_method = opts[:multi_remove_method] || :"remove_#{opts[:name]}"
+            multi_remove_method = nil if remove_method == multi_remove_method
+            if multi_remove_method
+              association_module_def(multi_remove_method, opts) do |objs, *args|
+                db.transaction(:server=>@server){objs.map{|obj| send(remove_method, obj, *args)}.compact}
+              end
+            end
+          end
+
+          if multi_add_method && multi_remove_method
+            association_module_def(:"#{opts[:name]}=", opts) do |objs, *args|
+              db.transaction(:server=>@server) do
+                existing_objs = send(opts.association_method)
+                send(multi_remove_method, (existing_objs - objs), *args)
+                send(multi_add_method, (objs - existing_objs), *args)
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/association_proxies.rb

@@ -64,6 +64,8 @@ module Sequel
         array = [].freeze
 
         if RUBY_VERSION < '2.6'
+          # :nocov:
+
           # Default proc used to determine whether to send the method to the dataset.
           # If the array would respond to it, sends it to the array instead of the dataset.
           DEFAULT_PROXY_TO_DATASET = proc do |opts|
@@ -73,10 +75,9 @@ module Sequel
             end
             !array_method
           end
-        else
           # :nocov:
+        else
           DEFAULT_PROXY_TO_DATASET = proc{|opts| !array.respond_to?(opts[:method])}
-          # :nocov:
         end
 
         # Set the association reflection to use, and whether the association should be

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/class_table_inheritance.rb

@@ -108,6 +108,16 @@ module Sequel
     #   a = Executive.where{{employees[:id]=>1}}.first # works
     #   a = Executive.where{{executives[:id]=>1}}.first # doesn't work
     #
+    # Note that because subclass datasets select from a subquery, you cannot update,
+    # delete, or insert into them directly.  To delete related rows, you need to go
+    # through the related tables and remove the related rows.  Code that does this would
+    # be similar to:
+    #
+    #   pks = Executive.where{num_staff < 10}.select_map(:id)
+    #   Executive.cti_tables.reverse_each do |table|
+    #     DB.from(table).where(:id=>pks).delete
+    #   end
+    #
     # = Usage
     #
     #   # Use the default of storing the class name in the sti_key

data/lib/sequel/plugins/csv_serializer.rb

@@ -65,8 +65,6 @@ module Sequel
     #   # Add CSV output capability to Album class instances
     #   Album.plugin :csv_serializer
     module CsvSerializer
-      CSV = Object.const_defined?(:CSV) ? ::CSV : ::FasterCSV
-
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values
       def self.configure(model, opts = OPTS)
@@ -75,13 +73,29 @@ module Sequel
         end
       end
 
+      # Avoid keyword argument separation warnings on Ruby 2.7, while still
+      # being compatible with 1.9.
+      if RUBY_VERSION >= "2.0"
+        instance_eval(<<-END, __FILE__, __LINE__+1)
+          def self.csv_call(*args, opts, &block)
+            CSV.send(*args, **opts, &block)
+          end
+        END
+      else
+        # :nodoc:
+        def self.csv_call(*args, opts, &block)
+          CSV.send(*args, opts, &block)
+        end
+        # :nodoc:
+      end
+
       module ClassMethods
         # The default opts to use when serializing model objects to CSV
         attr_reader :csv_serializer_opts
 
         # Attempt to parse an array of instances from the given CSV string
         def array_from_csv(csv, opts = OPTS)
-          CSV.parse(csv, process_csv_serializer_opts(opts)).map do |row|
+          CsvSerializer.csv_call(:parse, csv, process_csv_serializer_opts(opts)).map do |row|
             row = row.to_hash
             row.delete(nil)
             new(row)
@@ -108,7 +122,8 @@ module Sequel
           opts_cols = opts.delete(:columns)
           opts_include = opts.delete(:include)
           opts_except = opts.delete(:except)
-          opts[:headers] ||= Array(opts.delete(:only) || opts_cols || columns) + Array(opts_include) - Array(opts_except)
+          only = opts.delete(:only) 
+          opts[:headers] ||= Array(only || opts_cols || columns) + Array(opts_include) - Array(opts_except)
           opts
         end
 
@@ -130,7 +145,7 @@ module Sequel
         # :headers :: The headers to use for the CSV line. Use nil for a header
         #             to specify the column should be ignored.
         def from_csv(csv, opts = OPTS)
-          row = CSV.parse_line(csv, model.process_csv_serializer_opts(opts)).to_hash
+          row = CsvSerializer.csv_call(:parse_line, csv, model.process_csv_serializer_opts(opts)).to_hash
           row.delete(nil)
           set(row)
         end
@@ -146,9 +161,10 @@ module Sequel
         #             attributes to include in the CSV output.
         def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts(opts)
+          headers = opts[:headers]
 
-          CSV.generate(opts) do |csv|
-            csv << opts[:headers].map{|k| public_send(k)}
+          CsvSerializer.csv_call(:generate, model.process_csv_serializer_opts(opts)) do |csv|
+            csv << headers.map{|k| public_send(k)}
           end
         end
       end
@@ -164,10 +180,11 @@ module Sequel
         def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts({:columns=>columns}.merge!(opts))
           items = opts.delete(:array) || self
+          headers = opts[:headers]
 
-          CSV.generate(opts) do |csv|
+          CsvSerializer.csv_call(:generate, opts) do |csv|
             items.each do |object|
-              csv << opts[:headers].map{|header| object.public_send(header) }
+              csv << headers.map{|header| object.public_send(header)}
             end
           end
         end