sequel 5.95.1 → 5.97.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1ce1e79be7d6ab1cbb8cedfb80a162a81af9f2efe3de83102c2377e023e2f81
-  data.tar.gz: 93d997767f449e42cb76618207e816e4057277ca47d66371fa31903d3934bb91
+  metadata.gz: 236cf31a3c7848a6699dc871558a387748593a83dda8a722aad2e1c6beaad2d9
+  data.tar.gz: 974c8617fcecc74f10fab9c7fa8dd9e2f74a7a56767cf47cafd95e1108cc5f57
 SHA512:
-  metadata.gz: 88aa3c9f86d2bf1e5286605291c162d84dc0e8a2fa7cf002767234b431f8ff9719729ba93c89f62e98a7e33be4f02dba4826a09315ae0fe387f95d60ae9e1cda
-  data.tar.gz: 1f0c1e589056f3f0f6b2585e3dbf5e76a9173170357f37c59cff1ee8a4dcb830699f7e4a7bdd413947dab79f3f51f6bef5bc2902ebab030963a4ef8cf8de3ce8
+  metadata.gz: 5b396689d99af2a0882358e80150dc452b96a9cd09a73a9cdace42b903dd0958d341bf67e0570bd382dd051df54dc66b2d2b3e396506518c619d08bd006ebd1b
+  data.tar.gz: '0839e0177ccbb9d67880835b92e0b8767ea339b96375da914d0471a2cc24f25cdffbd8ada3b45ba69bdfc167a4609ed44fde1a7fd1db4c7574dff3f2efbfd80f'

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

@@ -154,6 +154,11 @@ module Sequel
         @operations << {:op => :alter_constraint, :name => name}.merge!(opts)
       end
 
+      # :inherit :: Set true to use INHERIT, or false to use NO INHERIT (PostgreSQL 18+)
+      def rename_constraint(name, new_name)
+        @operations << {:op => :rename_constraint, :name => name, :new_name => new_name}
+      end
+
       # Validate the constraint with the given name, which should have
       # been added previously with NOT VALID.
       def validate_constraint(name)
@@ -566,6 +571,7 @@ module Sequel
       #         :if_exists :: Don't raise an error if the schema doesn't exist.
       def drop_schema(name, opts=OPTS)
         self << drop_schema_sql(name, opts)
+        remove_all_cached_schemas
       end
 
       # Drops a trigger from the database.  Arguments:
@@ -721,6 +727,14 @@ module Sequel
         Sequel.synchronize{@primary_key_sequences[quoted_table] = value} if value
       end
 
+      # Rename a schema in the database. Arguments:
+      # name :: Current name of the schema
+      # opts :: New name for the schema
+      def rename_schema(name, new_name)
+        self << rename_schema_sql(name, new_name)
+        remove_all_cached_schemas
+      end
+
       # Refresh the materialized view with the given name.
       # 
       #   DB.refresh_view(:items_view)
@@ -1210,6 +1224,10 @@ module Sequel
         Postgres::AlterTableGenerator
       end
     
+      def alter_table_rename_constraint_sql(table, op)
+        "RENAME CONSTRAINT #{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
+      end
+
       def alter_table_set_column_type_sql(table, op)
         s = super
         if using = op[:using]
@@ -1291,7 +1309,7 @@ module Sequel
             sql << (identity == :always ? "ALWAYS" : "BY DEFAULT")
             sql << " AS IDENTITY"
           elsif (generated = column[:generated_always_as])
-            sql << " GENERATED ALWAYS AS (#{literal(generated)}) STORED"
+            sql << " GENERATED ALWAYS AS (#{literal(generated)}) #{column[:virtual] ? 'VIRTUAL' : 'STORED'}"
           end
         end
       end
@@ -1797,6 +1815,18 @@ module Sequel
         super
       end
 
+      # Clear all cached schema information
+      def remove_all_cached_schemas
+        @primary_keys.clear
+        @primary_key_sequences.clear
+        @schemas.clear
+      end
+
+      # SQL for renaming a schema.
+      def rename_schema_sql(name, new_name)
+        "ALTER SCHEMA #{quote_identifier(name)} RENAME TO #{quote_identifier(new_name)}"
+      end
+
       # SQL DDL statement for renaming a table. PostgreSQL doesn't allow you to change a table's schema in
       # a rename table operation, so specifying a new schema in new_name will not have an effect.
       def rename_table_sql(name, new_name)

data/lib/sequel/database/schema_generator.rb

@@ -156,6 +156,9 @@ module Sequel
       # PostgreSQL specific options:
       #
       # :identity :: Create an identity column.
+      # :virtual :: When using :generated_always_as, create a VIRTUAL column instead of a STORED
+      #             column (PostgreSQL 18+). VIRTUAL is the default if not specified on
+      #             PostgreSQL 18+, but for backwards compatibility, Sequel's default is STORED.
       #
       # MySQL specific options:
       #

data/lib/sequel/dataset/actions.rb

@@ -1256,8 +1256,6 @@ module Sequel
     # receiver's current order. This yields the row and the array of order expressions
     # to the block, which should return an array of values to use.
     def ignore_values_preceding(row)
-      @opts[:order].map{|v| v.is_a?(SQL::OrderedExpression) ? v.expression : v}
-
       order_exprs = @opts[:order].map do |v|
         if v.is_a?(SQL::OrderedExpression)
           descending = v.descending

data/lib/sequel/extensions/looser_typecasting.rb

@@ -37,18 +37,11 @@ module Sequel
       value.to_s
     end
 
-    if RUBY_VERSION >= '2.4'
-      def _typecast_value_string_to_decimal(value)
-        BigDecimal(value)
-      rescue
-        BigDecimal('0.0')
-      end
-    else
-      # :nocov:
-      def _typecast_value_string_to_decimal(value)
-        BigDecimal(value)
-      end
-      # :nocov:
+    # Typecast invalid BigDecimal to 0.0.
+    def _typecast_value_string_to_decimal(value)
+      BigDecimal(value)
+    rescue
+      BigDecimal('0.0')
     end
   end
 

data/lib/sequel/extensions/pg_array_ops.rb

@@ -56,6 +56,13 @@
 #   ia.join(':', ' ')  # array_to_string(int_array_column, ':', ' ')
 #   ia.unnest          # unnest(int_array_column)
 #   ia.unnest(:b)      # unnest(int_array_column, b)
+#
+# On PostgreSQL 18+, the following are supported:
+#
+#   ia.sort                # array_sort(int_array_column)
+#   ia.sort(desc: true)    # array_sort(int_array_column, true)
+#   ia.sort(nulls: :first) # array_sort(int_array_column, false, true)
+#   ia.reverse             # array_reverse(int_array_column)
 # 
 # See the PostgreSQL array function and operator documentation for more
 # details on what these functions and operators do.
@@ -217,6 +224,40 @@ module Sequel
         ArrayOp.new(function(:array_replace, element, replacement))
       end
 
+      # Call the array_reverse method:
+      #
+      #   array_op.reverse # array_reverse(array)
+      def reverse
+        function(:array_reverse)
+      end
+      
+      # Call the array_sort method. Options:
+      #
+      # :desc :: Sort in descending order instead of ascending order.
+      # :nulls :: If sorting in ascending order and value is :first, include NULL
+      #           values before non-NULL values. If sorting in descending order and
+      #           value is :last, include non-NULL values before NULL values.
+      #
+      #   array_op.sort                           # array_sort(array)
+      #   array_op.sort(desc: true)               # array_sort(array, true)
+      #   array_op.sort(nulls: :first)            # array_sort(array, false, true)
+      #   array_op.sort(desc: true, nulls: :last) # array_sort(array, true, false)
+      def sort(opts=OPTS)
+        desc = opts[:desc]
+        nulls = opts[:nulls]
+        if desc
+          if nulls == :last
+            function(:array_sort, true, false)
+          else
+            function(:array_sort, true)
+          end
+        elsif nulls == :first
+          function(:array_sort, false, true)
+        else
+          function(:array_sort)
+        end
+      end
+      
       # Call the array_to_string method:
       #
       #   array_op.join           # array_to_string(array, '')

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -348,6 +348,8 @@ module Sequel
         # automatically parameterized.
         def auto_param_type(v)
           case v
+          when Symbol
+            false
           when String
             case v
             when LiteralString

data/lib/sequel/extensions/pg_json_ops.rb

@@ -166,6 +166,11 @@
 #   #   "d" date EXISTS FALSE ON ERROR
 #   # ))
 #
+# On PostgreSQL 18+, strip_nulls can take an argument for whether to strip in arrays
+#
+#   j.strip_nulls(in_arrays: true)   # json_strip_nulls(json_column, true)
+#   j.strip_nulls(in_arrays: false)  # json_strip_nulls(json_column, false)
+#
 # 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
@@ -380,11 +385,22 @@ module Sequel
         self.class.new(JSONQueryOp.new(self, path, opts))
       end
 
-      # Returns a json value stripped of all internal null values.
+      # Returns a json value stripped of all internal null values. Options:
+      #
+      # :in_arrays :: Whether to strip null values in JSON arrays
       #
-      #   json_op.strip_nulls # json_strip_nulls(json)
-      def strip_nulls
-        self.class.new(function(:strip_nulls))
+      #   json_op.strip_nulls                   # json_strip_nulls(json)
+      #   json_op.strip_nulls(in_arrays: true)  # json_strip_nulls(json, true)
+      #   json_op.strip_nulls(in_arrays: false) # json_strip_nulls(json, false)
+      def strip_nulls(opts=OPTS)
+        in_arrays = opts[:in_arrays]
+        f = if in_arrays.nil?
+          function(:strip_nulls)
+        else
+          function(:strip_nulls, in_arrays)
+        end
+
+        self.class.new(f)
       end
 
       # Returns json_table SQL function expression, querying JSON data and returning

data/lib/sequel/extensions/pg_multirange.rb

@@ -339,7 +339,7 @@ module Sequel
 
       # Allow automatic parameterization.
       def sequel_auto_param_type(ds)
-        "::#{db_type}"
+        "::#{db_type}" if all?{|range| range.is_a?(Range) || ds.send(:auto_param_type, range)}
       end
     end
   end

data/lib/sequel/extensions/pg_range.rb

@@ -421,6 +421,17 @@ module Sequel
         @exclude_end
       end
 
+      # Support a friendly output
+      def inspect
+        range = if empty?
+          "empty"
+        else
+          "#{@exclude_begin ? "(" : "["}#{@begin},#{@end}#{@exclude_end ? ")" : "]"}"
+        end
+
+        "#<#{self.class.name} #{range}#{"::#{@db_type}" if @db_type}>"
+      end
+
       # Append a literalize version of the receiver to the sql.
       def sql_literal_append(ds, sql)
         if (s = @db_type) && !empty?
@@ -481,9 +492,9 @@ module Sequel
         end
       end
 
-      # Allow automatic parameterization for ranges with types.
+      # Allow automatic parameterization for ranges with types, if both start .
       def sequel_auto_param_type(ds)
-        "::#{db_type}" if db_type
+        "::#{db_type}" if db_type && (!@begin || ds.send(:auto_param_type, @begin)) && (!@end || ds.send(:auto_param_type, @end))
       end
 
       private

data/lib/sequel/model/associations.rb

@@ -3063,7 +3063,7 @@ module Sequel
           if (((op == :'=' || op == :'!=') && r.is_a?(Sequel::Model)) ||
               (multiple = ((op == :IN || op == :'NOT IN') && ((is_ds = r.is_a?(Sequel::Dataset)) || (r.respond_to?(:all?) && r.all?{|x| x.is_a?(Sequel::Model)})))))
             l = args[0]
-            if ar = model.association_reflections[l]
+            if ar = model.association_reflection(l)
               raise Error, "filtering by associations is not allowed for #{ar.inspect}" if ar[:allow_filtering_by] == false
 
               if multiple

data/lib/sequel/model/base.rb

@@ -1358,17 +1358,16 @@ END
         @values.keys
       end
       
-      # Refresh this record using +for_update+ (by default, or the specified style when given)
+      # Refresh this record using +:update+ lock style (by default, or the specified style when given),
       # unless this is a new record.  Returns self. This can be used to make sure no other
-      # process is updating the record at the same time.
+      # process can modify the record during the transaction containing this call.  Using
+      # this method only makes sense inside transactions.
       #
       # If style is a string, it will be used directly. You should never pass a string
       # to this method that is derived from user input, as that can lead to
       # SQL injection.
       #
-      # A symbol may be used for database independent locking behavior, but
-      # all supported symbols have separate methods (e.g. for_update).
-      #
+      # A symbol may be used if the adapter supports that lock style.
       #
       #   a = Artist[1]
       #   Artist.db.transaction do
@@ -1378,7 +1377,7 @@ END
       #
       #   a = Artist[2]
       #   Artist.db.transaction do
-      #     a.lock!('FOR NO KEY UPDATE')
+      #     a.lock!(:no_key_update)
       #     a.update(name: 'B')
       #   end
       def lock!(style=:update)

data/lib/sequel/plugins/deprecated_associations.rb

@@ -0,0 +1,151 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The deprecated_associations plugin adds support for
+    # deprecating associations. Attempts to use association
+    # methods and access association metadata for deprecated
+    # associations results in a warning.
+    #
+    #   Album.plugin :deprecated_associations
+    #   Album.many_to_one :artist, deprecated: true
+    #   album = Album[1]
+    #
+    #   # Warnings for all of the following calls
+    #   album.artist
+    #   album.artist_dataset
+    #   album.artist = Artist[2]
+    #   Album.association_reflection(:artist)
+    #   Album.eager(:artist)
+    #   Album.eager_graph(:artist)
+    #   Album.where(artist: Artist[1]).all
+    #
+    # By default, the plugin issues a single warning per
+    # association method or association reflection. See
+    # DeprecatedAssociations.configure for options to make
+    # deprecated association issue warnings for every access,
+    # to include backtraces in warnings, or to raise an
+    # exception instead of warning.
+    #
+    # Note that Model.association_reflections and
+    # Model.all_association_reflections will include deprecated
+    # associations, and accessing the metadata for deprecated
+    # associations through these interfaces not issue warnings.
+    #
+    # Usage:
+    #
+    #   # Make all models support deprecated associations
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :deprecated_associations
+    #
+    #   # Make Album class support deprecated associations
+    #   Album.plugin :deprecated_associations
+    module DeprecatedAssociations
+      # Exception class used for deprecated association use when
+      # raising exceptions instead of emitting warnings.
+      class Access < Sequel::Error; end
+
+      # Configure the deprecated associations plugin. Options:
+      #
+      # backtrace: Print backtrace with warning
+      # deduplicate: Set to false to emit warnings for every
+      #              deprecated association method call/access
+      #              (when not caching associations, this is always false)
+      # raise: Raise Sequel::Plugin::DeprecatedAssociations::Access
+      #        instead of warning
+      def self.configure(model, opts = OPTS)
+        model.instance_exec do
+          (@deprecated_associations_config ||= {}).merge!(opts)
+        end
+      end
+
+      module ClassMethods
+        # Issue a deprecation warning if the association is deprecated.
+        def association_reflection(assoc)
+          ref = super
+          if ref && ref[:deprecated]
+            emit_deprecated_association_warning(ref, nil) do
+              "Access of association reflection for deprecated association: class:#{name} association:#{assoc}"
+            end
+          end
+          ref
+        end
+
+        private
+
+        # Issue a deprecation warning when the defined method is called if the
+        # association is deprecated and the method name does not start with the
+        # underscore (to avoid not warning twice, once for the public association
+        # method and once for the private association method).
+        def association_module_def(name, opts=OPTS, &block)
+          super
+          if opts[:deprecated] && name[0] != "_"
+            deprecated_associations_module.module_exec do
+              define_method(name) do |*a, &b|
+                self.class.send(:emit_deprecated_association_warning, opts, name) do
+                  "Calling deprecated association method: class:#{self.class.name} association:#{opts[:name]} method:#{name}"
+                end
+                super(*a, &b)
+              end
+              alias_method name, name
+            end
+          end
+          nil
+        end
+
+        # Issue a deprecation warning when the defined method is called if the
+        # association is deprecated.
+        def association_module_delegate_def(name, opts, &block)
+          super
+          if opts[:deprecated]
+            deprecated_associations_module.module_exec do
+              define_method(name) do |*a, &b|
+                self.class.send(:emit_deprecated_association_warning, opts, name) do
+                  "Calling deprecated association method: class:#{self.class.name} association:#{opts[:name]} method:#{name}"
+                end
+                super(*a, &b)
+              end
+              # :nocov:
+              ruby2_keywords(name) if respond_to?(:ruby2_keywords, true)
+              # :nocov:
+              alias_method(name, name)
+            end
+          end
+          nil
+        end
+
+        # A module to add deprecated association methods to. These methods
+        # handle issuing the deprecation warnings, and call super to get the
+        # default behavior.
+        def deprecated_associations_module
+          return @deprecated_associations_module if defined?(@deprecated_associations_module)
+          @deprecated_associations_module = Module.new
+          include(@deprecated_associations_module)
+          @deprecated_associations_module
+        end
+
+        # Emit a deprecation warning, or raise an exception if the :raise
+        # plugin option was used.
+        def emit_deprecated_association_warning(ref, method)
+          config = @deprecated_associations_config
+
+          raise Access, yield if config[:raise]
+
+          unless config[:deduplicate] == false
+            emit = false
+            ref.send(:cached_fetch, [:deprecated_associations, method]) do
+              emit = true
+            end
+            return unless emit
+          end
+
+          if config[:backtrace]
+            warn yield, caller(2)
+          else
+            warn yield, :uplevel => 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/json_serializer.rb

@@ -106,13 +106,7 @@ module Sequel
     # and breaks some aspects of the json_serializer plugin.  You can undo the damage
     # done by active_support/json by doing:
     #
-    #   module ActiveSupportBrokenJSONFix
-    #     def to_json(options = {})
-    #       JSON.generate(self)
-    #     end
-    #   end
-    #   Array.send(:prepend, ActiveSupportBrokenJSONFix)
-    #   Hash.send(:prepend, ActiveSupportBrokenJSONFix)
+    #   ActiveSupport::ToJsonWithActiveSupportEncoder.send(:remove_method, :to_json)
     #
     # Note that this will probably cause active_support/json to no longer work
     # correctly in some cases.

data/lib/sequel/version.rb

@@ -6,11 +6,11 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 95
+  MINOR = 97
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
-  TINY  = 1
+  TINY  = 0
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   VERSION = [MAJOR, MINOR, TINY].join('.').freeze

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.95.1
+  version: 5.97.0
 platform: ruby
 authors:
 - Jeremy Evans
@@ -342,6 +342,7 @@ files:
 - lib/sequel/plugins/def_dataset_method.rb
 - lib/sequel/plugins/defaults_setter.rb
 - lib/sequel/plugins/delay_add_association.rb
+- lib/sequel/plugins/deprecated_associations.rb
 - lib/sequel/plugins/dirty.rb
 - lib/sequel/plugins/eager_each.rb
 - lib/sequel/plugins/eager_graph_eager.rb