sequel 5.81.0 → 5.83.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a23afa1510b7bd1ba6918319eedce156450672520ab4798e6de56461a59660e1
-  data.tar.gz: bb6bbfbf0f1f82fe117fa8c725e9cf4fde49644a74b463ab8682018744a8a1de
+  metadata.gz: 66956ac28806c0389a6c809b0aa70d2746a7aff47fd5b039d238c08f621cdbff
+  data.tar.gz: d2b8d3f88b13432c60e6164fda3577725300e18a0dfa03682871405d074d7ba0
 SHA512:
-  metadata.gz: 9e26620f8f1df2715205e9019c2012ec2e9f392d14ed427d66c76f488bccc3e5d3f27e4d626a47d54903d611695db0487f987d99191602024a1864d6c10f7bde
-  data.tar.gz: cd070d8c35960949039d226b5eaf8c90ebec8d0cef3f09b5dae533551bb35170ca6e2503d88f1b1512110b6617ff9c03d9cb2afb62395c4d953314aa5a5ca87c
+  metadata.gz: 55d45f7c3cb7154f275ddf5ea3649d78a38f147abdb49f1286358d8dbec9f607e3bf43c9ebe1dc31276d28820f455fc82dcce7b4c9808b325288380acf90edf4
+  data.tar.gz: b8301c7880dcb598ca027d225f5be791200ac1f13f4efe5351222d351b218019351a8efa1f485d499a0650cd4213ba0a148c3f10f0a67aa0b3c04f4ee611b074

data/CHANGELOG

@@ -1,3 +1,33 @@
+=== 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)
+
+* Fix race condition in threaded/sharded_threaded connection pools that could cause stalls (jeremyevans)
+
+* Emulate dropping a unique column or a column that is part of an index on SQLite 3.35.0+ (jeremyevans) (#2176)
+
+* Support MERGE RETURNING on PostgreSQL 17+ (jeremyevans)
+
+* Remove use of logger library in bin/sequel (jeremyevans)
+
+* Support :connect_opts_proc Database option for late binding options (jeremyevans) (#2164)
+
 === 5.81.0 (2024-06-01)
 
 * Fix ignored block warnings in a couple plugin apply methods on Ruby 3.4 (jeremyevans)

data/bin/sequel

@@ -61,8 +61,7 @@ options = OptionParser.new do |opts|
   end
   
   opts.on("-E", "--echo", "echo SQL statements") do
-    require 'logger'
-    loggers << Logger.new($stdout)
+    loggers << $stdout
   end
   
   opts.on("-I", "--include dir", "specify $LOAD_PATH directory") do |v|
@@ -70,8 +69,9 @@ options = OptionParser.new do |opts|
   end
 
   opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
-    require 'logger'
-    loggers << Logger.new(v)
+    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|
@@ -155,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/opening_databases.rdoc

@@ -79,6 +79,9 @@ These options are shared by all adapters unless otherwise noted.
                or string with extensions separated by columns.  These extensions are loaded after
                connections are made by the :preconnect option.
 :cache_schema :: Whether schema should be cached for this database (true by default)
+:connect_opts_proc :: Callable object for modifying options hash used when connecting, designed for
+                      cases where the option values (e.g. password) are automatically rotated on
+                      a regular basis without involvement from the application using Sequel.
 :default_string_column_size :: The default size for string columns (255 by default)
 :host :: The hostname of the database server to which to connect
 :keep_reference :: Whether to keep a reference to the database in Sequel::DATABASES (true by default)

data/doc/release_notes/5.82.0.txt

@@ -0,0 +1,61 @@
+= New Features
+
+* MERGE RETURNING is now supported when using PostgreSQL 17+. For
+  datasets supporting RETURNING, calling merge with a block
+  will yield each returned row:
+
+    DB[:table1].
+      returning.
+      merge_using(:table2, column1: :column2).
+      merge_insert(column3: :column4).
+      merge do |row|
+        # ...
+      end
+    # MERGE INTO "table1" USING "table2"
+    # ON ("column1" = "column2")
+    # WHEN NOT MATCHED THEN
+    # INSERT ("column3") VALUES ("column3")
+    # RETURNING *
+
+* A :connect_opts_proc Database option is now supported, to allow
+  support for late-binding Database options.  If provided, this
+  should be a callable object that is called with the options
+  used for connecting, and can modify the options.  This makes
+  it simple to support authentication schemes that rotate
+  passwords automatically without user involvement:
+
+    Sequel.connect('postgres://user@host/database',
+      connect_opts_proc: lambda do |opts|
+        opts[:password] = SomeAuthLibrary.get_current_password(opts[:user])
+      end)
+
+  Note that the jdbc adapter relies on URIs and not option hashes,
+  so when using the jdbc adapter with this feature, you'll generally
+  need to set the :uri option.
+
+= Other Improvements
+
+* A race condition in the threaded connection pools that could result
+  in a delay or timeout error in checking out connections in low-traffic
+  environments has been fixed.
+
+* Sequel now supports dropping a unique column or a column that is
+  part of an index on SQLite 3.35.0+, with the same emulation approach
+  it uses in earlier SQLite versions.
+
+* The tactical_eager_loading plugin now handles cases where inheritance
+  is used and the objects used include associations with the same name
+  but different definitions.  Sequel will now only eager load the
+  association for objects that use the same association definition as
+  the receiver.
+
+= Backwards Compatibility
+
+* bin/sequel no longer requires logger if passed the -E or -l options.
+  Instead, it uses a simple implementation that supports only
+  debug/warn/info/error methods.  If you are using bin/sequel and
+  depending on the log format produced by the logger library, or
+  calling methods on the logger object other than
+  debug/warn/info/error, you'll need to update your code.  This change
+  was made because logger is moving out of stdlib in a future Ruby
+  version.

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.
+
+* 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/doc/testing.rdoc

@@ -47,6 +47,20 @@ These run each test in its own transaction, the recommended way to test.
     end
   end
 
+== Transactional testing with multiple threads
+
+Some tests may require executing code across multiple threads. The most common example are browser tests with Capybara, where the web server is running in a separate thread. For transactional tests to work in this case, the main thread needs to allow other threads to use its database connection while the transaction is in progress. This can be achieved with the temporarily_release_connection extension:
+
+  DB.extension :temporarily_release_connection
+  DB.transaction(rollback: :always, auto_savepoint: true) do |conn|
+    DB.temporarily_release_connection(conn) do
+      # Other threads can operate on connection safely inside the transaction
+      yield
+    end
+  end
+
+This requires maximum connection pool size to be 1, so make sure to set the Database +:max_connections+ option to 1 in tests.
+
 == Transactional testing with multiple databases
 
 You can use the Sequel.transaction method to run a transaction on multiple databases, rolling all of them back.  Instead of:

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
@@ -2058,6 +2058,29 @@ module Sequel
         nil
       end
 
+      # Support MERGE RETURNING on PostgreSQL 17+.
+      def merge(&block)
+        sql = merge_sql
+        if uses_returning?(:merge)
+          returning_fetch_rows(sql, &block)
+        else
+          execute_ddl(sql)
+        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.
@@ -2084,15 +2107,41 @@ 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}
-        if override = @opts[:override]
+        if @opts[:override]
           h[:override] = insert_override_sql(String.new)
         end
         _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.
@@ -2170,9 +2219,14 @@ module Sequel
         true
       end
 
-      # Returning is always supported.
+      # MERGE RETURNING is supported on PostgreSQL 17+. Other RETURNING is supported
+      # on all supported PostgreSQL versions.
       def supports_returning?(type)
-        true
+        if type == :merge
+          server_version >= 170000
+        else
+          true
+        end
       end
 
       # PostgreSQL supports pattern matching via regular expressions
@@ -2281,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]
@@ -2290,10 +2344,15 @@ 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)
+        super
+        insert_returning_sql(sql) if uses_returning?(:merge)
+      end
 
       # Format TRUNCATE statement with PostgreSQL specific options.
       def _truncate_sql(table)

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

@@ -245,7 +245,7 @@ module Sequel
             super
           end
         when :drop_column
-          if sqlite_version >= 33500
+          if sqlite_version >= 33500 && !indexes(table).any?{|_, h| h[:columns].include?(op[:name])}
             super
           else
             ocp = lambda{|oc| oc.delete_if{|c| c.to_s == op[:name].to_s}}

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -197,11 +197,8 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     timeout = @timeout
     timer = Sequel.start_timer
 
-    sync do
-      @waiters[server].wait(@mutex, timeout)
-      if conn = next_available(server)
-        return(allocated(server)[thread] = conn)
-      end
+    if conn = acquire_available(thread, server, timeout)
+      return conn
     end
 
     until conn = assign_connection(thread, server)
@@ -211,11 +208,8 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
 
       # It's difficult to get to this point, it can only happen if there is a race condition
       # where a connection cannot be acquired even after the thread is signalled by the condition variable
-      sync do
-        @waiters[server].wait(@mutex, timeout - elapsed)
-        if conn = next_available(server)
-          return(allocated(server)[thread] = conn)
-        end
+      if conn = acquire_available(thread, server, timeout - elapsed)
+        return conn
       end
       # :nocov:
     end
@@ -223,6 +217,28 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     conn
   end
 
+  # Acquire a connection if one is already available, or waiting until it becomes available.
+  def acquire_available(thread, server, timeout)
+    sync do
+      # Check if connection was checked in between when assign_connection failed and now.
+      # This is very unlikely, but necessary to prevent a situation where the waiter
+      # will wait for a connection even though one has already been checked in.
+      # :nocov:
+      if conn = next_available(server)
+        return(allocated(server)[thread] = conn)
+      end
+      # :nocov:
+
+      @waiters[server].wait(@mutex, timeout)
+
+      # Connection still not available, could be because a connection was disconnected,
+      # may have to retry assign_connection to see if a new connection can be made.
+      if conn = next_available(server)
+        return(allocated(server)[thread] = conn)
+      end
+    end
+  end
+
   # Assign a connection to the thread, or return nil if one cannot be assigned.
   # The caller should NOT have the mutex before calling this.
   def assign_connection(thread, server)

data/lib/sequel/connection_pool/threaded.rb

@@ -143,11 +143,8 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     timeout = @timeout
     timer = Sequel.start_timer
 
-    sync do
-      @waiter.wait(@mutex, timeout)
-      if conn = next_available
-        return(@allocated[thread] = conn)
-      end
+    if conn = acquire_available(thread, timeout)
+      return conn
     end
 
     until conn = assign_connection(thread)
@@ -157,11 +154,8 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
 
       # It's difficult to get to this point, it can only happen if there is a race condition
       # where a connection cannot be acquired even after the thread is signalled by the condition variable
-      sync do
-        @waiter.wait(@mutex, timeout - elapsed)
-        if conn = next_available
-          return(@allocated[thread] = conn)
-        end
+      if conn = acquire_available(thread, timeout - elapsed)
+        return conn
       end
       # :nocov:
     end
@@ -169,6 +163,28 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     conn
   end
 
+  # Acquire a connection if one is already available, or waiting until it becomes available.
+  def acquire_available(thread, timeout)
+    sync do
+      # Check if connection was checked in between when assign_connection failed and now.
+      # This is very unlikely, but necessary to prevent a situation where the waiter
+      # will wait for a connection even though one has already been checked in.
+      # :nocov:
+      if conn = next_available
+        return(@allocated[thread] = conn)
+      end
+      # :nocov:
+
+      @waiter.wait(@mutex, timeout)
+
+      # Connection still not available, could be because a connection was disconnected,
+      # may have to retry assign_connection to see if a new connection can be made.
+      if conn = next_available
+        return(@allocated[thread] = conn)
+      end
+    end
+  end
+
   # Assign a connection to the thread, or return nil if one cannot be assigned.
   # The caller should NOT have the mutex before calling this.
   def assign_connection(thread)

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(:uri_to_options, uri).merge!(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
       when Hash
         opts = conn_string.merge(opts)
@@ -270,28 +267,20 @@ module Sequel
       @single_threaded
     end
     
-    if RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.5'
-    # :nocov:
-      def synchronize(server=nil)
-        @pool.hold(server || :default){|conn| yield conn}
-      end
-    # :nocov:
-    else
-      # Acquires a database connection, yielding it to the passed block. This is
-      # useful if you want to make sure the same connection is used for all
-      # database queries in the block.  It is also useful if you want to gain
-      # direct access to the underlying connection object if you need to do
-      # something Sequel does not natively support.
-      #
-      # If a server option is given, acquires a connection for that specific
-      # server, instead of the :default server.
-      #
-      #   DB.synchronize do |conn|
-      #     # ...
-      #   end
-      def synchronize(server=nil, &block)
-        @pool.hold(server || :default, &block)
-      end
+    # Acquires a database connection, yielding it to the passed block. This is
+    # useful if you want to make sure the same connection is used for all
+    # database queries in the block.  It is also useful if you want to gain
+    # direct access to the underlying connection object if you need to do
+    # something Sequel does not natively support.
+    #
+    # If a server option is given, acquires a connection for that specific
+    # server, instead of the :default server.
+    #
+    #   DB.synchronize do |conn|
+    #     # ...
+    #   end
+    def synchronize(server=nil, &block)
+      @pool.hold(server || :default, &block)
     end
     
     # Attempts to acquire a database connection.  Returns true if successful.
@@ -343,6 +332,11 @@ module Sequel
       else
         @opts.dup
       end
+
+      if pr = opts[:connect_opts_proc]
+        pr.call(opts)
+      end
+
       opts.delete(:servers)
       opts
     end

data/lib/sequel/database/misc.rb

@@ -72,13 +72,16 @@ module Sequel
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object. 
     def self.uri_to_options(uri)
-      {
+      uri_options = {
         :user => uri.user,
         :password => uri.password,
         :port => uri.port,
         :host => uri.hostname,
         :database => (m = /\/(.*)/.match(uri.path)) && (m[1])
       }
+      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 :uri_to_options
 
@@ -108,6 +111,9 @@ module Sequel
     # :cache_schema :: Whether schema should be cached for this Database instance
     # :check_string_typecast_bytesize :: Whether to check the bytesize of strings before typecasting.
     # :connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
+    # :connect_opts_proc :: Callable object for modifying options hash used when connecting, designed for
+    #                       cases where the option values (e.g. password) are automatically rotated on
+    #                       a regular basis without involvement from the application using Sequel.
     # :default_string_column_size :: The default size of string columns, 255 by default.
     # :extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
     #                or string with extensions separated by columns.  These extensions are loaded after
@@ -250,15 +256,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(:uri_to_options, URI.parse(opts[:uri]))
       end
-      "#<#{self.class}: #{a.join(' ')}>"
+
+      keys.each do |key|
+        val = opts[key]
+        if val && val != ''
+          s << " #{key}=#{val}"
+        end
+      end
+
+      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/association_pks.rb

@@ -294,7 +294,7 @@ module Sequel
           sch = klass.db_schema
 
           if primary_key.is_a?(Array)
-            if (cols = sch.values_at(*klass.primary_key)).all? && (convs = cols.map{|c| c[:type] == :integer}).all?
+            if (cols = sch.values_at(*klass.primary_key)).all? && (cols.map{|c| c[:type] == :integer}).all?
               db = model.db
               pks.map do |cpk|
                 cpk.map do |pk|

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/plugins/tactical_eager_loading.rb

@@ -158,15 +158,19 @@ module Sequel
         end
 
         # Filter the objects used when tactical eager loading.
-        # By default, this removes frozen objects and objects that alreayd have the association loaded
+        # By default, this removes frozen objects and objects that alreayd have the association loaded,
+        # as well as objects where the reflection for the association is not the same as the receiver's
+        # reflection for the association.
         def _filter_tactical_eager_load_objects(opts)
           objects = defined?(super) ? super : retrieved_with.dup
+          name = opts[:name]
           if opts[:eager_reload]
             objects.reject!(&:frozen?)
           else
-            name = opts[:name]
             objects.reject!{|x| x.frozen? || x.associations.include?(name)}
           end
+          reflection = self.class.association_reflection(name)
+          objects.select!{|x| x.class.association_reflection(name).equal?(reflection)}
           objects
         end
       end

data/lib/sequel/plugins/validate_associated.rb

@@ -53,7 +53,7 @@ module Sequel
         def validate_associated_object(reflection, obj)
           return if reflection[:validate] == false
           association = reflection[:name]
-          if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !(pk_val = obj.values[key])
+          if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !(obj.values[key])
             p_key = pk unless pk.is_a?(Array)
             if p_key
               obj.values[key] = p_key

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 81
+  MINOR = 83
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.81.0
+  version: 5.83.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-01 00:00:00.000000000 Z
+date: 2024-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -229,6 +229,8 @@ extra_rdoc_files:
 - doc/release_notes/5.8.0.txt
 - 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
@@ -338,6 +340,8 @@ files:
 - doc/release_notes/5.8.0.txt
 - 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
@@ -517,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
@@ -672,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