sequel 5.82.0 → 5.83.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f09a139a164322e0a0e52e9a58c79b2f463972363509c41bf50e7082c1f542b7
-  data.tar.gz: e7222b81a79111b9853565160f81cb18c72b341f18bec839046c9b49a4b199ea
+  metadata.gz: 892c809f3a378e80b21c29cc1c7f95f4a9fd0b47621a10d314b6177641f1ed4b
+  data.tar.gz: be68a7d44ecd5af4e7d7d67484ea6fc200e663b8649c250fcfc4be11de9f4c3d
 SHA512:
-  metadata.gz: d9f16395ad855ccbc4494bd2e1436b6b78f15ddbfd1c9b80d356040d99415a46a352f50042b2fc9ab23d29b65567dafec2fceb35c709498159b00a1402991ee6
-  data.tar.gz: a5693c2f3c3791c0216a5af9e933edaa41b0eeb030a3523e52a6951c666e720d0b12ec48ae3f46777ce617b27857f6519d7ce98ec1768a0c8226c4b494e501c1
+  metadata.gz: ac626e338969ddf7e99b554070b7383e3ce2e712ca2033b1c65dc2181c36636740a4e1858fa6cdb6bede1493a93aeac8299bbc26acfb2ed515a654a2957de7e4
+  data.tar.gz: 660dc4b4bded4eb08e357d92f093be43ac8613e62f1a8a693d1c6d81b64ddec3081147303ac10cd9153f8d62d2ce3459d8fd871412156fd5342c325ca654371c

data/CHANGELOG

@@ -1,3 +1,23 @@
+=== 5.83.1 (2024-08-08)
+
+* Restore unescaping of database file paths in the sqlite and amalgalite adapters (jeremyevans) (#2201)
+
+=== 5.83.0 (2024-08-01)
+
+* Make optimistic_locking plugin not keep lock column in changed_columns after updating instance (jeremyevans) (#2196)
+
+* Have defaults_setter plugin pass model instance to default_values callable if it has arity 1 (pedrocarmona) (#2195)
+
+* Support string_agg extension on SQLite 3.44+ (segiddins) (#2191)
+
+* Support schema-qualified table names when using create_table :temp with a Sequel::SQL::QualifiedIdentifier (jeremyevans) (#2185)
+
+* Support MERGE WHEN NOT MATCHED BY SOURCE on PostgreSQL 17+ (jeremyevans)
+
+* Add stdio_logger extension for a minimal logger that Sequel::Database can use (jeremyevans)
+
+* Simplify Database#inspect output to database_type, host, database, and user (jeremyevans)
+
 === 5.82.0 (2024-07-01)
 
 * Limit tactically eager loading to objects that have the same association reflection (jeremyevans) (#2181)

data/bin/sequel

@@ -18,21 +18,6 @@ load_dirs = []
 exclusive_options = []
 loggers = []
 
-logger_class = Class.new do
-  def initialize(device)
-    @device = device
-  end
-
-  def debug(msg)
-  end
-
-  [:info, :warn, :error].each do |meth|
-    define_method(meth) do |msg|
-      @device.puts("#{Time.now.strftime('%Y-%m-%d %T')} #{meth.to_s.upcase}: #{msg}")
-    end
-  end
-end
-
 options = OptionParser.new do |opts|
   opts.banner = "Sequel: The Database Toolkit for Ruby"
   opts.define_head "Usage: sequel [options] <uri|path> [file]"
@@ -76,7 +61,7 @@ options = OptionParser.new do |opts|
   end
   
   opts.on("-E", "--echo", "echo SQL statements") do
-    loggers << logger_class.new($stdout)
+    loggers << $stdout
   end
   
   opts.on("-I", "--include dir", "specify $LOAD_PATH directory") do |v|
@@ -84,7 +69,9 @@ options = OptionParser.new do |opts|
   end
 
   opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
-    loggers << logger_class.new(File.open(v, 'a'))
+    file = File.open(v, 'a')
+    file.sync = true
+    loggers << file
   end
   
   opts.on("-L", "--load-dir DIR", "loads all *.rb under specifed directory") do |v|
@@ -168,6 +155,11 @@ begin
     end
   end
 
+  unless loggers.empty?
+    Sequel.extension :stdio_logger
+    loggers.map!{|io| Sequel::StdioLogger.new(io)}
+  end
+
   DB = connect_proc[db]
   load_dirs.each{|d| d.is_a?(Array) ? require(d.first) : Dir["#{d}/**/*.rb"].each{|f| load(f)}}
   if migrate_dir

data/doc/release_notes/5.83.0.txt

@@ -0,0 +1,56 @@
+= New Features
+
+* MERGE WHEN NOT MATCHED BY SOURCE is now supported when using
+  PostgreSQL 17+.  You can use this SQL syntax via the following
+  Dataset methods:
+
+  * merge_delete_when_not_matched_by_source
+  * merge_update_when_not_matched_by_source
+  * merge_do_nothing_when_not_matched_by_source
+
+  These are similar to the existing merge_delete, merge_update,
+  and merge_do_nothing_when_matched, except they use
+  WHEN NOT MATCHED BY SOURCE instead of WHEN MATCHED.
+
+* An stdio_logger extension has been added.  This adds the
+  Sequel::StdioLogger class, which is a minimal logger implementation
+  that is compatible for usage with Sequel::Database.  Example:
+
+    Sequel.extension :stdio_logger
+    DB.loggers << Sequel::StdioLogger.new($stdout)
+
+= Other Improvements
+
+* Database#inspect now only displays the database type, host, database
+  name, and user.  In addition to being easier to read, this also
+  prevents displaying the password, enhancing security.
+
+* The string_agg extension now supports SQLite 3.44+.
+
+* The defaults_setter plugin now passes the model instance to a
+  default_values proc if the proc has arity 1.  This allows default
+  values to depend on model instance state.
+
+* The optimistic_locking plugin no longer adds the lock column to
+  changed_columns after updating the model instance.
+
+* Database#create_temp with :temp option and an
+  SQL::QualifiedIdentifier table name will now attempt to create a
+  schema qualified table.  Note that schema qualified temporary
+  tables are not supported by many (any?) databases, but this
+  change prevents the CREATE TABLE statement from succeeding with
+  an unexpected table name.
+
+= Backwards Compatibility
+
+* The Database.uri_to_options private class method now handles
+  conversion of URI parameters to options.  Previously, this was
+  handled by callers of this method (change reverted in 5.83.1).
+
+* The _merge_matched_sql and _merge_not_matched_sql private Dataset
+  methods in PostgreSQL have been replaced with
+  _merge_do_nothing_sql.
+
+* An unnecessary space in submitted SQL has been removed when using
+  MERGE INSERT on PostgreSQL.  This should only affect your code if
+  you are explicitly checking the produced SQL.

data/lib/sequel/adapters/jdbc/derby.rb

@@ -115,7 +115,7 @@ module Sequel
         # Temporary table creation on Derby uses DECLARE instead of CREATE.
         def create_table_prefix_sql(name, options)
           if options[:temp]
-            "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)}"
+            "DECLARE GLOBAL TEMPORARY TABLE #{create_table_table_name_sql(name, options)}"
           else
             super
           end

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

@@ -198,7 +198,7 @@ module Sequel
       # http://www.ibm.com/developerworks/data/library/techarticle/dm-0912globaltemptable/
       def create_table_prefix_sql(name, options)
         if options[:temp]
-          "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)}"
+          "DECLARE GLOBAL TEMPORARY TABLE #{create_table_table_name_sql(name, options)}"
         else
           super
         end

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

@@ -379,9 +379,21 @@ module Sequel
       # a regular and temporary table, with temporary table names starting with
       # a #.
       def create_table_prefix_sql(name, options)
-        "CREATE TABLE #{quote_schema_table(options[:temp] ? "##{name}" : name)}"
+        "CREATE TABLE #{create_table_table_name_sql(name, options)}"
       end
-      
+
+      # The SQL to use for the table name for a temporary table.
+      def create_table_temp_table_name_sql(name, _options)
+        case name
+        when String, Symbol
+          "##{name}"
+        when SQL::Identifier
+          "##{name.value}"
+        else
+          raise Error, "temporary table names must be strings, symbols, or Sequel::SQL::Identifier instances on Microsoft SQL Server"
+        end
+      end
+
       # MSSQL doesn't support CREATE TABLE AS, it only supports SELECT INTO.
       # Emulating CREATE TABLE AS using SELECT INTO is only possible if a dataset
       # is given as the argument, it can't work with a string, so raise an

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

@@ -1429,7 +1429,7 @@ module Sequel
           'UNLOGGED '
         end
 
-        "CREATE #{prefix_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
+        "CREATE #{prefix_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{create_table_table_name_sql(name, options)}"
       end
 
       # SQL for creating a table with PostgreSQL specific options
@@ -2068,6 +2068,19 @@ module Sequel
         end
       end
 
+      # Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN DELETE clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_delete_not_matched_by_source
+      #   # WHEN NOT MATCHED BY SOURCE THEN DELETE
+      #
+      #   merge_delete_not_matched_by_source{a > 30}
+      #   # WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN DELETE
+      def merge_delete_when_not_matched_by_source(&block)
+        _merge_when(:type=>:delete_not_matched_by_source, &block)
+      end
+
       # Return a dataset with a WHEN MATCHED THEN DO NOTHING clause added to the
       # MERGE statement.  If a block is passed, treat it as a virtual row and
       # use it as additional conditions for the match.
@@ -2094,6 +2107,19 @@ module Sequel
         _merge_when(:type=>:not_matched, &block)
       end
 
+      # Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN DO NOTHING clause added to the
+      # MERGE BY SOURCE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_do_nothing_when_not_matched_by_source
+      #   # WHEN NOT MATCHED BY SOURCE THEN DO NOTHING
+      #
+      #   merge_do_nothing_when_not_matched_by_source{a > 30}
+      #   # WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN DO NOTHING
+      def merge_do_nothing_when_not_matched_by_source(&block)
+        _merge_when(:type=>:not_matched_by_source, &block)
+      end
+
       # Support OVERRIDING USER|SYSTEM VALUE for MERGE INSERT.
       def merge_insert(*values, &block)
         h = {:type=>:insert, :values=>values}
@@ -2103,6 +2129,19 @@ module Sequel
         _merge_when(h, &block)
       end
     
+      # Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN UPDATE clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_update_not_matched_by_source(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+      #   # WHEN NOT MATCHED BY SOURCE THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+      #
+      #   merge_update_not_matched_by_source(i1: :i2){a > 30}
+      #   # WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN UPDATE SET i1 = i2
+      def merge_update_when_not_matched_by_source(values, &block)
+        _merge_when(:type=>:update_not_matched_by_source, :values=>values, &block)
+      end
+
       # Use OVERRIDING USER VALUE for INSERT statements, so that identity columns
       # always use the user supplied value, and an error is not raised for identity
       # columns that are GENERATED ALWAYS.
@@ -2296,7 +2335,7 @@ module Sequel
 
       # Append the INSERT sql used in a MERGE
       def _merge_insert_sql(sql, data)
-        sql << " THEN INSERT "
+        sql << " THEN INSERT"
         columns, values = _parse_insert_sql_args(data[:values])
         _insert_columns_sql(sql, columns)
         if override = data[:override]
@@ -2305,10 +2344,9 @@ module Sequel
         _insert_values_sql(sql, values)
       end
 
-      def _merge_matched_sql(sql, data)
+      def _merge_do_nothing_sql(sql, data)
         sql << " THEN DO NOTHING"
       end
-      alias _merge_not_matched_sql _merge_matched_sql
 
       # Support MERGE RETURNING on PostgreSQL 17+.
       def _merge_when_sql(sql)

data/lib/sequel/database/connecting.rb

@@ -34,10 +34,7 @@ module Sequel
           uri = URI.parse(conn_string)
           scheme = uri.scheme
           c = adapter_class(scheme)
-          uri_options = c.send(:uri_to_options, uri)
-          uri.query.split('&').map{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
-          uri_options.to_a.each{|k,v| uri_options[k] = URI::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
-          opts = uri_options.merge(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
+          opts = c.send(:options_from_uri, uri).merge!(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
       when Hash
         opts = conn_string.merge(opts)

data/lib/sequel/database/misc.rb

@@ -82,6 +82,14 @@ module Sequel
     end
     private_class_method :uri_to_options
 
+    def self.options_from_uri(uri)
+      uri_options = uri_to_options(uri)
+      uri.query.split('&').map{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
+      uri_options.to_a.each{|k,v| uri_options[k] = URI::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
+      uri_options
+    end
+    private_class_method :options_from_uri
+
     # The options hash for this database
     attr_reader :opts
     
@@ -253,15 +261,27 @@ module Sequel
       Sequel.convert_output_timestamp(v, timezone)
     end
 
-    # Returns a string representation of the database object including the
-    # class name and connection URI and options used when connecting (if any).
+    # Returns a string representation of the Database object, including
+    # the database type, host, database, and user, if present.
     def inspect
-      a = []
-      a << uri.inspect if uri
-      if (oo = opts[:orig_opts]) && !oo.empty?
-        a << oo.inspect
+      s = String.new
+      s << "#<#{self.class}"
+      s << " database_type=#{database_type}" if database_type && database_type != adapter_scheme
+
+      keys = [:host, :database, :user]
+      opts = self.opts
+      if !keys.any?{|k| opts[k]} && opts[:uri]
+        opts = self.class.send(:options_from_uri, URI.parse(opts[:uri]))
+      end
+
+      keys.each do |key|
+        val = opts[key]
+        if val && val != ''
+          s << " #{key}=#{val}"
+        end
       end
-      "#<#{self.class}: #{a.join(' ')}>"
+
+      s << ">"
     end
 
     # Proxy the literal call to the dataset.

data/lib/sequel/database/schema_methods.rb

@@ -775,7 +775,21 @@ module Sequel
 
     # SQL fragment for initial part of CREATE TABLE statement
     def create_table_prefix_sql(name, options)
-      "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
+      "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{create_table_table_name_sql(name, options)}"
+    end
+
+    # The SQL to use for a table name when creating a table.
+    # Use of the :temp option can result in different SQL,
+    # because the rules for temp table naming can differ
+    # between databases, and temp tables should not use the
+    # default_schema.
+    def create_table_table_name_sql(name, options)
+      options[:temp] ? create_table_temp_table_name_sql(name, options) : quote_schema_table(name)
+    end
+
+    # The SQL to use for the table name for a temporary table.
+    def create_table_temp_table_name_sql(name, _options)
+      name.is_a?(String) ? quote_identifier(name) : literal(name)
     end
 
     # SQL fragment for initial part of CREATE VIEW statement

data/lib/sequel/dataset/sql.rb

@@ -901,18 +901,31 @@ module Sequel
     MERGE_TYPE_SQL = {
       :insert => ' WHEN NOT MATCHED',
       :delete => ' WHEN MATCHED',
+      :delete_not_matched_by_source => ' WHEN NOT MATCHED BY SOURCE',
       :update => ' WHEN MATCHED',
+      :update_not_matched_by_source => ' WHEN NOT MATCHED BY SOURCE',
       :matched => ' WHEN MATCHED',
       :not_matched => ' WHEN NOT MATCHED',
+      :not_matched_by_source => ' WHEN NOT MATCHED BY SOURCE',
     }.freeze
     private_constant :MERGE_TYPE_SQL
 
+    MERGE_NORMALIZE_TYPE_MAP = {
+      :delete_not_matched_by_source => :delete,
+      :update_not_matched_by_source => :update,
+      :matched => :do_nothing,
+      :not_matched => :do_nothing,
+      :not_matched_by_source => :do_nothing,
+    }.freeze
+    private_constant :MERGE_NORMALIZE_TYPE_MAP
+
     # Add the WHEN clauses to the MERGE SQL
     def _merge_when_sql(sql)
       raise Error, "no WHEN [NOT] MATCHED clauses provided for MERGE" unless merge_when = @opts[:merge_when]
       merge_when.each do |data|
         type = data[:type]
         sql << MERGE_TYPE_SQL[type]
+        type = MERGE_NORMALIZE_TYPE_MAP[type] || type
         _merge_when_conditions_sql(sql, data)
         send(:"_merge_#{type}_sql", sql, data)
       end

data/lib/sequel/extensions/stdio_logger.rb

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+#
+# The stdio_logger extension exposes a Sequel::StdioLogger class that
+# can be used for logging with Sequel, as a minimal alternative to
+# the logger library.  It exposes debug/info/warn/error methods for the
+# different warning levels.  The debug method is a no-op, so that setting
+# the Database sql_log_level to debug will result in no output for normal
+# queries. The info/warn/error methods log the current time, log level,
+# and the given message.
+# 
+# To use this extension:
+#
+#   Sequel.extension :stdio_logger
+#
+# Then you you can use Sequel::StdioLogger to wrap IO objects that you
+# would like Sequel to log to:
+#
+#   DB.loggers << Sequel::StdioLogger.new($stdout)
+#
+#   log_file = File.open("db_queries.log", 'a')
+#   log_file.sync = true
+#   DB.loggers << Sequel::StdioLogger.new(log_file)
+#
+# This is implemented as a global extension instead of a Database extension
+# because Database loggers must be set before Database extensions are loaded.
+#
+# Related module: Sequel::StdioLogger
+
+#
+module Sequel
+  class StdioLogger
+    def initialize(device)
+      @device = device
+    end
+
+    # Do not log debug messages. This is so setting the Database
+    # sql_log_level to debug will result in no output.
+    def debug(msg)
+    end
+
+    [:info, :warn, :error].each do |meth|
+      define_method(meth) do |msg|
+        @device.write("#{Time.now.strftime('%F %T')} #{meth.to_s.upcase}: #{msg}\n")
+        nil
+      end
+    end
+  end
+end

data/lib/sequel/extensions/string_agg.rb

@@ -54,6 +54,7 @@
 # * MySQL
 # * HSQLDB
 # * H2
+# * SQLite 3.44+ (distinct only works when separator is ',')
 #
 # Related module: Sequel::SQL::StringAgg
 
@@ -94,6 +95,19 @@ module Sequel
           distinct = sa.is_distinct?
 
           case db_type = db.database_type
+          when :sqlite
+            raise Error, "string_agg(DISTINCT) is not supported with a non-comma separator on #{db.database_type}" if distinct && separator != ","
+
+            args = [expr]
+            args << separator unless distinct
+            f = Function.new(:group_concat, *args)
+            if order
+              f = f.order(*order)
+            end
+            if distinct
+              f = f.distinct
+            end
+            literal_append(sql, f)
           when :postgres, :sqlanywhere
             f = Function.new(db_type == :postgres ? :string_agg : :list, expr, separator)
             if order
@@ -151,7 +165,7 @@ module Sequel
         freeze
       end
 
-      # Whether the current expression uses distinct expressions 
+      # Whether the current expression uses distinct expressions
       def is_distinct?
         @distinct == true
       end
@@ -178,4 +192,3 @@ module Sequel
 
   Dataset.register_extension(:string_agg, SQL::StringAgg::DatasetMethods)
 end
-

data/lib/sequel/plugins/defaults_setter.rb

@@ -26,6 +26,12 @@ module Sequel
     #   Album.default_values[:a] = lambda{Date.today}
     #   Album.new.a # => Date.today
     #
+    # If the proc accepts a single argument, it is passed the instance, allowing
+    # default values to depend on instance-specific state:
+    #
+    #   Album.default_values[:a] = lambda{|album| album.b + 1}
+    #   Album.new(b: 10).a # => 11
+    #
     # By default, default values returned are not cached:
     #
     #   Album.new.a.equal?(Album.new.a) # => false
@@ -43,13 +49,13 @@ module Sequel
     #   album.values # => {}
     #   album.a
     #   album.values # => {:a => Date.today}
-    # 
+    #
     # Usage:
     #
     #   # Make all model subclass instances set defaults (called before loading subclasses)
     #   Sequel::Model.plugin :defaults_setter
     #
-    #   # Make the Album class set defaults 
+    #   # Make the Album class set defaults
     #   Album.plugin :defaults_setter
     module DefaultsSetter
       # Set the default values based on the model schema. Options:
@@ -76,7 +82,7 @@ module Sequel
         def cache_default_values?
           @cache_default_values
         end
-        
+
         # Freeze default values when freezing model class
         def freeze
           @default_values.freeze
@@ -133,7 +139,13 @@ module Sequel
         def [](k)
           if new? && !values.has_key?(k)
             v = model.default_values.fetch(k){return}
-            v = v.call if v.respond_to?(:call)
+            if v.respond_to?(:call)
+              v = if v.respond_to?(:arity) && v.arity == 1
+                v.call(self)
+              else
+                v.call
+              end
+            end
             values[k] = v if model.cache_default_values?
             v
           else

data/lib/sequel/plugins/optimistic_locking.rb

@@ -45,6 +45,8 @@ module Sequel
           columns[lc] = lcv + 1
           super
           set_column_value("#{lc}=", lcv + 1)
+          changed_columns.delete(lc)
+          nil
         end
       end
     end

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 = 82
+  MINOR = 83
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
-  TINY  = 0
+  TINY  = 1
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   VERSION = [MAJOR, MINOR, TINY].join('.').freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.82.0
+  version: 5.83.1
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 2024-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -230,6 +230,7 @@ extra_rdoc_files:
 - doc/release_notes/5.80.0.txt
 - doc/release_notes/5.81.0.txt
 - doc/release_notes/5.82.0.txt
+- doc/release_notes/5.83.0.txt
 - doc/release_notes/5.9.0.txt
 files:
 - CHANGELOG
@@ -340,6 +341,7 @@ files:
 - doc/release_notes/5.80.0.txt
 - doc/release_notes/5.81.0.txt
 - doc/release_notes/5.82.0.txt
+- doc/release_notes/5.83.0.txt
 - doc/release_notes/5.9.0.txt
 - doc/schema_modification.rdoc
 - doc/security.rdoc
@@ -519,6 +521,7 @@ files:
 - lib/sequel/extensions/sql_expr.rb
 - lib/sequel/extensions/sql_log_normalizer.rb
 - lib/sequel/extensions/sqlite_json_ops.rb
+- lib/sequel/extensions/stdio_logger.rb
 - lib/sequel/extensions/string_agg.rb
 - lib/sequel/extensions/string_date_time.rb
 - lib/sequel/extensions/symbol_aref.rb
@@ -674,7 +677,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: The Database Toolkit for Ruby