sequel 5.107.0 → 5.108.0

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

@@ -204,12 +204,12 @@ module Sequel
         @in = v
       end
 
-      # Assumes hash partitioning, sets the modulus for this parition.
+      # Assumes hash partitioning, sets the modulus for this partition.
       def modulus(v)
         @modulus = v
       end
 
-      # Assumes hash partitioning, sets the remainder for this parition.
+      # Assumes hash partitioning, sets the remainder for this partition.
       def remainder(v)
         @remainder = v
       end
@@ -406,13 +406,13 @@ module Sequel
             Data.new(@name, @key, @labels, @source, @destination).freeze
           end
 
-          # Specify the source for the edge, with block evaluted by Target.
+          # Specify the source for the edge, with block evaluated by Target.
           def source(name, &block)
             raise Error, "cannot specify multiple sources for a property graph edge" if @source
             @source = Target.new(name, &block)
           end
 
-          # Specify the destination for the edge, with block evaluted by Target.
+          # Specify the destination for the edge, with block evaluated by Target.
           def destination(name, &block)
             raise Error, "cannot specify multiple destinations for a property graph edge" if @destination
             @destination = Target.new(name, &block)
@@ -437,12 +437,12 @@ module Sequel
             Data.new(@vertices, @edges).freeze
           end
 
-          # Adds a vertex to the property graph, with the block evaluted by Vertex.
+          # Adds a vertex to the property graph, with the block evaluated by Vertex.
           def vertex(name, opts=OPTS, &block)
             @vertices << Vertex.new(name, opts, &block)
           end
 
-          # Adds an edge to the property graph, with the block evaluted by Edge.
+          # Adds an edge to the property graph, with the block evaluated by Edge.
           def edge(name, opts=OPTS, &block)
             @edges << Edge.new(name, opts, &block)
           end
@@ -962,7 +962,7 @@ module Sequel
       # Keys are CHECK constraint name symbols.  Values are hashes with the following keys:
       # :definition :: An SQL fragment for the definition of the constraint
       # :columns :: An array of column symbols for the columns referenced in the constraint,
-      #             can be an empty array if the database cannot deteremine the column symbols.
+      #             can be an empty array if the database cannot determine the column symbols.
       def check_constraints(table)
         m = output_identifier_meth
 
@@ -1354,7 +1354,7 @@ module Sequel
       #
       # link :: Add a bidirectional link to a new element (vertex or edge)
       # to :: Add a directional link from the last element to the new element
-      # from :: Add a direciton link from the new element to last element
+      # from :: Add a direction link from the new element to last element
       # columns :: Replace the columns the graph table returns
       # add_columns :: Append to the columns the graph table returns.
       #
@@ -1378,7 +1378,7 @@ module Sequel
       #   gt = gt.to(:v2)
       #   # GRAPH_TABLE ("pgn" MATCH (IS "iv")-[IS "e1"]->(IS "v2") COLUMNS ("c", 1 AS "d"))
       #
-      #   # Adds bidirection link from vertex to vertex (overriding the default)
+      #   # Adds bidirectional link from vertex to vertex (overriding the default)
       #   gt = gt.link(:v3, vertex: true)
       #   # GRAPH_TABLE ("pgn" MATCH (IS "iv")-[IS "e1"]->(IS "v2")-(IS "v3") COLUMNS ("c", 1 AS "d"))
       #
@@ -1556,12 +1556,12 @@ module Sequel
           seq_ds = metadata_dataset.from(:pg_sequence).where(:seqrelid=>regclass_oid(LiteralString.new(seq.freeze)))
           increment_by = :seqincrement
           min_value = :seqmin
-        # :nocov:
+        # simplecov:disable
         else
           seq_ds = metadata_dataset.from(LiteralString.new(seq))
           increment_by = :increment_by
           min_value = :min_value
-        # :nocov:
+        # simplecov:enable
         end
 
         get{setval(seq, db[table].select(coalesce(max(pk)+seq_ds.select(increment_by), seq_ds.select(min_value))), false)}
@@ -1574,9 +1574,9 @@ module Sequel
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
       def serial_primary_key_options
-        # :nocov:
+        # simplecov:disable
         auto_increment_key = server_version >= 100002 ? :identity : :serial
-        # :nocov:
+        # simplecov:enable
         {:primary_key => true, auto_increment_key => true, :type=>Integer}
       end
 
@@ -1773,12 +1773,12 @@ module Sequel
         if server_version >= 90500
           cpos = Sequel.expr{array_position(co[:conkey], ctable[:attnum])}
           rpos = Sequel.expr{array_position(co[:confkey], rtable[:attnum])}
-        # :nocov:
+        # simplecov:disable
         else
           range = 0...32
           cpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, ctable[:attnum])}
           rpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, rtable[:attnum])}
-        # :nocov:
+        # simplecov:enable
         end
 
         ds = metadata_dataset.
@@ -1815,19 +1815,19 @@ module Sequel
       def _add_validated_enforced_constraint_columns(ds)
         validated_cond = if server_version >= 90100
           Sequel[:convalidated]
-        # :nocov:
+        # simplecov:disable
         else
           Sequel.cast(true, TrueClass)
-        # :nocov:
+        # simplecov:enable
         end
         ds = ds.select_append(validated_cond.as(:validated))
 
         enforced_cond = if server_version >= 180000
           Sequel[:conenforced]
-        # :nocov:
+        # simplecov:disable
         else
           Sequel.cast(true, TrueClass)
-        # :nocov:
+        # simplecov:enable
         end
         ds = ds.select_append(enforced_cond.as(:enforced))
 
@@ -1839,11 +1839,11 @@ module Sequel
         @_indexes_ds ||= begin
           if server_version >= 90500
             order = [Sequel[:indc][:relname], Sequel.function(:array_position, Sequel[:ind][:indkey], Sequel[:att][:attnum])]
-          # :nocov:
+          # simplecov:disable
           else
             range = 0...32
             order = [Sequel[:indc][:relname], SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(Sequel[:ind][:indkey], [x]), x]}, 32, Sequel[:att][:attnum])]
-          # :nocov:
+          # simplecov:enable
           end
 
           attnums = SQL::Function.new(:ANY, Sequel[:ind][:indkey])
@@ -1861,10 +1861,10 @@ module Sequel
             order(*order).
             select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
 
-          # :nocov:
+          # simplecov:disable
           ds = ds.where(:indisready=>true) if server_version >= 80300
           ds = ds.where(:indislive=>true) if server_version >= 90300
-          # :nocov:
+          # simplecov:enable
 
           ds
         end
@@ -1957,14 +1957,14 @@ module Sequel
             where{pg_attribute[:attnum] > 0}.
             order{pg_attribute[:attnum]}
 
-          # :nocov:
+          # simplecov:disable
           if server_version > 100000
-          # :nocov:
+          # simplecov:enable
             ds = ds.select_append{pg_attribute[:attidentity]}
 
-            # :nocov:
+            # simplecov:disable
             if server_version > 120000
-            # :nocov:
+            # simplecov:enable
               ds = ds.select_append{Sequel.~(pg_attribute[:attgenerated]=>'').as(:generated)}
             end
           end
@@ -2554,7 +2554,7 @@ module Sequel
         "#{super}#{create_table_suffix_sql(name, options)}"
       end
 
-      # Handle various PostgreSQl specific table extensions such as inheritance,
+      # Handle various PostgreSQL specific table extensions such as inheritance,
       # partitioning, tablespaces, and foreign tables.
       def create_table_suffix_sql(name, options)
         sql = String.new
@@ -2858,9 +2858,9 @@ module Sequel
             row[:auto_increment] = !!(row[:default] =~ /\A(?:nextval)/i) || identity == 'a' || identity == 'd'
           end
 
-          # :nocov:
+          # simplecov:disable
           if server_version >= 90600
-          # :nocov:
+          # simplecov:enable
             case row[:oid]
             when 1082
               row[:min_value] = MIN_DATE
@@ -2949,9 +2949,9 @@ module Sequel
     
       # PostgreSQL 9.4+ supports views with check option.
       def view_with_check_option_support
-        # :nocov:
+        # simplecov:disable
         :local if server_version >= 90400
-        # :nocov:
+        # simplecov:enable
       end
     end
 
@@ -3054,12 +3054,12 @@ module Sequel
           rows[0]
         elsif rows.all?{|row| String === row}
           rows.join("\r\n") 
-        # :nocov:
+        # simplecov:disable
         else
           # This branch is unreachable in tests, but it seems better to just return
           # all rows than throw in error if this case actually happens.
           rows
-        # :nocov:
+        # simplecov:enable
         end
       end
 
@@ -3181,8 +3181,11 @@ module Sequel
       # Handle uniqueness violations when inserting, by updating the conflicting row, using
       # ON CONFLICT. With no options, uses ON CONFLICT DO NOTHING.  Options:
       # :conflict_where :: The index filter, when using a partial index to determine uniqueness.
-      # :constraint :: An explicit constraint name, has precendence over :target.
+      # :constraint :: An explicit constraint name, has precedence over :target.
       # :target :: The column name or expression to handle uniqueness violations on.
+      # :select :: Use ON CONFLICT DO SELECT. This will use the dataset's lock style.
+      #            You must use #returning on this dataset when using this option.
+      # :select_where :: A WHERE condition to use for the select.
       # :update :: A hash of columns and values to set.  Uses ON CONFLICT DO UPDATE.
       # :update_where :: A WHERE condition to use for the update.
       #
@@ -3213,7 +3216,21 @@ module Sequel
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
       #   # ON CONFLICT ON CONSTRAINT table_a_uidx
       #   # DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)
+      #   
+      #   DB[:table].returning(:a).insert_conflict(target: :a, select: true).insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) DO SELECT RETURNING a
+      #   
+      #   DB[:table].returning(:a).for_update.
+      #     insert_conflict(target: :a, select: true, select_where: {Sequel[:excluded][:b] => 3}).
+      #     insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) DO SELECT FOR UPDATE WHERE (excluded.b = 3) RETURNING a
       def insert_conflict(opts=OPTS)
+        if opts[:select] && opts[:update]
+          raise Error, "Cannot provide both :select and :update options to insert_conflict"
+        end
+
         clone(:insert_conflict => opts)
       end
 
@@ -3454,14 +3471,14 @@ module Sequel
         server_version >= 90500
       end
 
-      # :nocov:
+      # simplecov:disable
 
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
         # SEQUEL6: Remove
         true
       end
-      # :nocov:
+      # simplecov:enable
 
       # PostgreSQL 8.4+ supports WINDOW clause.
       def supports_window_clause?
@@ -3576,7 +3593,7 @@ module Sequel
       end
 
       # Use from_self for aggregate dataset using VALUES.
-      def aggreate_dataset_use_from_self?
+      def aggregate_dataset_use_from_self?
         super || @opts[:values]
       end
       
@@ -3638,7 +3655,7 @@ module Sequel
         origin = String.new
         origin << 'EXPLAIN '
 
-        # :nocov:
+        # simplecov:disable
         if server_version < 90000
           if opts[:analyze]
             origin << 'ANALYZE '
@@ -3646,7 +3663,7 @@ module Sequel
 
           return origin
         end
-        # :nocov:
+        # simplecov:enable
 
         comma = nil
         paren = "("
@@ -3726,13 +3743,19 @@ module Sequel
           if values = opts[:update]
             sql << " DO UPDATE SET "
             update_sql_values_hash(sql, values)
-            if update_where = opts[:update_where]
-              sql << " WHERE "
-              literal_append(sql, update_where)
-            end
+            where = opts[:update_where]
+          elsif opts[:select]
+            sql << " DO SELECT"
+            select_lock_sql(sql)
+            where = opts[:select_where]
           else
             sql << " DO NOTHING"
           end
+
+          if where
+            sql << " WHERE "
+            literal_append(sql, where)
+          end
         end
       end
 

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

@@ -210,7 +210,7 @@ module Sequel
           if ops.length > 1 && ops.all?{|op| op[:op] == :add_constraint || op[:op] == :set_column_null}
             null_ops, ops = ops.partition{|op| op[:op] == :set_column_null}
 
-            # Apply NULL/NOT NULL ops first, since those should be purely idependent of the constraints.
+            # Apply NULL/NOT NULL ops first, since those should be purely independent of the constraints.
             null_ops.each{|op| alter_table_sql_list(table, [op]).flatten.each{|sql| execute_ddl(sql)}}
 
             # If you are just doing constraints, apply all of them at the same time,
@@ -730,7 +730,7 @@ module Sequel
 
       # Handle uniqueness violations when inserting, by using a specified
       # resolution algorithm. With no options, uses INSERT OR REPLACE. SQLite
-      # supports the following conflict resolution algoriths: ROLLBACK, ABORT,
+      # supports the following conflict resolution algorithms: ROLLBACK, ABORT,
       # FAIL, IGNORE and REPLACE.
       #
       # On SQLite 3.24.0+, you can pass a hash to use an ON CONFLICT clause.
@@ -892,7 +892,7 @@ module Sequel
       end
 
       # Use from_self for aggregate dataset using VALUES.
-      def aggreate_dataset_use_from_self?
+      def aggregate_dataset_use_from_self?
         super || @opts[:values]
       end
       

data/lib/sequel/adapters/utils/emulate_offset_with_reverse_and_count.rb

@@ -49,7 +49,7 @@ module Sequel
       else
         # Sequel doesn't allow a nonpositive limit.  If the offset
         # is greater than the number of rows, the empty result set
-        # shuld be returned, so use a condition that is always false.
+        # should be returned, so use a condition that is always false.
         ds.where(1=>0)
       end
       sql = @opts[:append_sql] || String.new

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -22,7 +22,17 @@ module Sequel
         END
         # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
         MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/
-       
+
+        # 2027 (CR_MALFORMED_PACKET) deliberately not included (protocol error, not connection error)
+        MYSQL_DISCONNECT_ERROR_CODES = [
+          2002, # CR_CONNECTION_ERROR
+          2006, # CR_SERVER_GONE_ERROR
+          2013, # CR_SERVER_LOST
+          2014, # CR_COMMANDS_OUT_OF_SYNC
+          2055, # CR_SERVER_LOST_EXTENDED
+        ].freeze
+        private_constant :MYSQL_DISCONNECT_ERROR_CODES
+
         # Support stored procedures on MySQL
         def call_sproc(name, opts=OPTS, &block)
           args = opts[:args] || [] 

data/lib/sequel/connection_pool/sharded_single.rb

@@ -38,7 +38,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   
   # Disconnects from the database. Once a connection is requested using
   # #hold, the connection is reestablished. Options:
-  # :server :: Should be a symbol specifing the server to disconnect from,
+  # :server :: Should be a symbol specifying the server to disconnect from,
   #            or an array of symbols to specify multiple servers.
   def disconnect(opts=OPTS)
     (opts[:server] ? Array(opts[:server]) : servers).each do |s|

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+# SEQUEL6: Remove, deprecation: add warning if used on Ruby 3.2+
+
 require_relative 'threaded'
 
 # The slowest and most advanced connection pool, dealing with both multi-threaded
@@ -95,7 +97,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # 
   # Once a connection is requested using #hold, the connection pool
   # creates new connections to the database. Options:
-  # :server :: Should be a symbol specifing the server to disconnect from,
+  # :server :: Should be a symbol specifying the server to disconnect from,
   #            or an array of symbols to specify multiple servers.
   def disconnect(opts=OPTS)
     (opts[:server] ? Array(opts[:server]) : sync{@servers.keys}).each do |s|
@@ -203,7 +205,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
 
     until conn = assign_connection(thread, server)
       elapsed = Sequel.elapsed_seconds_since(timer)
-      # :nocov:
+      # simplecov:disable
       raise_pool_timeout(elapsed, server) if elapsed > timeout
 
       # It's difficult to get to this point, it can only happen if there is a race condition
@@ -211,7 +213,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       if conn = acquire_available(thread, server, timeout - elapsed)
         return conn
       end
-      # :nocov:
+      # simplecov:enable
     end
 
     conn
@@ -223,11 +225,11 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       # 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:
+      # simplecov:disable
       if conn = next_available(server)
         return(allocated(server)[thread] = conn)
       end
-      # :nocov:
+      # simplecov:enable
 
       @waiters[server].wait(@mutex, timeout)
 

data/lib/sequel/connection_pool/sharded_timed_queue.rb

@@ -1,8 +1,8 @@
 # frozen-string-literal: true
 
-# :nocov:
+# simplecov:disable
 raise LoadError, "Sequel::ShardedTimedQueueConnectionPool is only available on Ruby 3.2+" unless RUBY_VERSION >= '3.2'
-# :nocov:
+# simplecov:enable
 
 # A connection pool allowing multi-threaded access to a sharded pool of connections,
 # using a timed queue (only available in Ruby 3.2+).
@@ -148,7 +148,7 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
     @queues[pick_server(server)].num_waiting
   end
 
-  # The total number of connections in the pool. Using a non-existant server will return nil.
+  # The total number of connections in the pool. Using a non-existent server will return nil.
   def size(server=:default)
     sync{@sizes[server]}
   end

data/lib/sequel/connection_pool/threaded.rb

@@ -1,9 +1,11 @@
 # frozen-string-literal: true
 
+# SEQUEL6: Remove, deprecation: add warning if used on Ruby 3.2+
+
 # A connection pool allowing multi-threaded access to a pool of connections.
 # This is the default connection pool used by Sequel.
 class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
-  USE_WAITER = true # SEQUEL6: Remove
+  USE_WAITER = true
   Sequel::Deprecation.deprecate_constant(self, :USE_WAITER)
 
   # The maximum number of connections this pool will create (per shard/server
@@ -12,11 +14,11 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   
   # An array of connections that are available for use by the pool.
   # The calling code should already have the mutex before calling this.
-  attr_reader :available_connections # SEQUEL6: Remove
+  attr_reader :available_connections
   
   # A hash with thread/fiber keys and connection values for currently allocated connections.
   # The calling code should already have the mutex before calling this.
-  attr_reader :allocated # SEQUEL6: Remove
+  attr_reader :allocated
 
   # The following additional options are respected:
   # :max_connections :: The maximum number of connections the connection pool
@@ -149,7 +151,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
 
     until conn = assign_connection(thread)
       elapsed = Sequel.elapsed_seconds_since(timer)
-      # :nocov:
+      # simplecov:disable
       raise_pool_timeout(elapsed) if elapsed > timeout
 
       # It's difficult to get to this point, it can only happen if there is a race condition
@@ -157,7 +159,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
       if conn = acquire_available(thread, timeout - elapsed)
         return conn
       end
-      # :nocov:
+      # simplecov:enable
     end
 
     conn
@@ -169,11 +171,11 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
       # 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:
+      # simplecov:disable
       if conn = next_available
         return(@allocated[thread] = conn)
       end
-      # :nocov:
+      # simplecov:enable
 
       @waiter.wait(@mutex, timeout)
 

data/lib/sequel/connection_pool/timed_queue.rb

@@ -1,8 +1,8 @@
 # frozen-string-literal: true
 
-# :nocov:
+# simplecov:disable
 raise LoadError, "Sequel::TimedQueueConnectionPool is only available on Ruby 3.2+" unless RUBY_VERSION >= '3.2'
-# :nocov:
+# simplecov:enable
 
 # A connection pool allowing multi-threaded access to a pool of connections,
 # using a timed queue (only available in Ruby 3.2+).

data/lib/sequel/connection_pool.rb

@@ -38,7 +38,7 @@ class Sequel::ConnectionPool
   POOL_CLASS_MAP.freeze
 
   # Class methods used to return an appropriate pool subclass, separated
-  # into a module for easier overridding by extensions.
+  # into a module for easier overriding by extensions.
   module ClassMethods
     # Return a pool subclass instance based on the given options.  If a <tt>:pool_class</tt>
     # option is provided is provided, use that pool class, otherwise
@@ -72,11 +72,11 @@ class Sequel::ConnectionPool
           opts[:servers] ? :sharded_single : :single
         elsif RUBY_VERSION >= '3.2'
           opts[:servers] ? :sharded_timed_queue : :timed_queue
-        # :nocov:
+        # simplecov:disable
         else
           opts[:servers] ? :sharded_threaded : :threaded
         end
-        # :nocov:
+        # simplecov:enable
 
         connection_pool_class(:pool_class=>pc)
       end