sequel 5.76.0 → 5.77.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca7f95e54ed437de173bbdfac08f4091f0e8debfb1a89bb168cd6157341afa9d
-  data.tar.gz: f49e07aec7ae48c509abf3965bc10ec102616d5ccc99ecb49d0116a9162760af
+  metadata.gz: 9951772dd3785c8ce91090bd31034a1e57ac5dcbc17af774b980a115cea15347
+  data.tar.gz: 3cfcaefaf6aa4758ef2cfaf78cbe6ccdc688e8b3836718bd63c42c5bdb220026
 SHA512:
-  metadata.gz: 9b8453bf85f48038160481a3b795a692a670b3e73084e6f531f353739c2549f809af5d45368db4dbcc0ac0bbd318eb4a94a02d0289d8c09117641f0ea4dc493d
-  data.tar.gz: a7daa11f1dc3d757f1618f4e8ee832c33e7072f375cfeea028e68b340414a159c92d05d76d75fd9bbb35cb498699ed9db32c9e7cbb158bb2b8a88e598ade34e6
+  metadata.gz: '0885577c11fd7285a5278d0a1b52ae411e557cec7bce2f3a49f8128a0be63928ebfa55b2b1a86c8b28ee1c3782c1dc5ebf5d4ecf00f0194ad33da89cb6ffc12a'
+  data.tar.gz: ccc7b8b6c68049ee1fed2211a3d193157ee36fde9c340324eba2a8cebd8925bc97b4dc1777b61f8a2fb94d83439c41f33afb832c080f4d54bab16d09924a4fe2

data/CHANGELOG

@@ -1,3 +1,23 @@
+=== 5.77.0 (2024-02-01)
+
+* Support create_table :without_rowid option on SQLite (loranger32) (#2126)
+
+* Warn by default if trying to eager_graph/association_join an association that uses a block, when the block would be ignored (jeremyevans)
+
+* Speed up validates_unique in validation_helpers plugin by using empty? instead of count == 0 (numbata) (#2122)
+
+* Speed up regexp matches in sqlite adapter on Ruby 2.4+ (jeremyevans)
+
+* Add sqlite adapter :regexp_function_cache option for specifying the cache object to use (paddor, jeremyevans) (#2116)
+
+* Respect list plugin :top option when inserting the first row into the model's table (johanmagnusson) (#2115)
+
+* Switch default connection pool to timed_queue on Ruby 3.4+ (jeremyevans)
+
+* Support on_duplicate_columns={raise,warn} parameter in connection URL when using duplicate_columns_handler extension (jeremyevans)
+
+* Add transaction_connection_validator extension for retrying transactions on new connection if ther is a disconnect error when starting transaction (jeremyevans)
+
 === 5.76.0 (2024-01-01)
 
 * Improve performance and flexibility of regexp matching in sqlite adapter (paddor) (#2108)

data/doc/release_notes/5.76.0.txt

@@ -42,7 +42,7 @@
 
 = Other Improvements
 
-* Time/DateTime/SQLite literalization speed has more than doubled
+* Time/DateTime/SQLTime literalization speed has more than doubled
   compared to the previous version.  The internal code is also much
   simpler, as the speedup resulted from removing multiple abstraction
   layers that mostly existed for Ruby 1.8 support.

data/doc/release_notes/5.77.0.txt

@@ -0,0 +1,63 @@
+= New Features
+
+* A transaction_connection_validator extension has been added.  This
+  extension allows for transparently switching to a new connection if
+  a disconnect error is raised while trying to start a transaction, as
+  long as a connection was not already checked out from the pool
+  when the transaction method was called.  Transparent reconnection
+  is safe in this case, since no user code is retried.
+
+  This extension can have lower overhead than the
+  connection_validator extension if that is configured to check for
+  validity more often than the default of one hour.  However, it
+  only handles cases where transactions are used.  It can detect
+  disconnects that would not be detected by default with the
+  connection_validator extension, since that extension defaults to
+  only checking validity if the connection has not been used in the
+  last hour.
+
+* Sequel now supports a create_table :without_rowid option on SQLite,
+  to create a table WITHOUT ROWID, for better performance in some
+  cases. Users are encouraged to read the SQLite documentation on
+  WITHOUT ROWID before using this option.
+
+* The sqlite adapter now supports a :regexp_function_cache option, if
+  the :setup_regexp_function option is set to :cached.  The
+  :regexp_function_cache option should be a Proc (returning a cache
+  object to use), or a class.  It's possible to use
+  ObjectSpace::WeakKeyMap as the value of the option on Ruby 3.3+
+  to avoid the memory leaks that are possible when using
+  :setup_regexp_function option :cached value with dynamic regexps.
+
+* The duplicate_columns_handler extension now supports specifying
+  the on_duplicate_columns option as a connection string parameter.
+
+= Other Improvements
+
+* The list plugin now honors the :top option for the position when
+  adding the first item to the list, instead of always using 1.
+
+* Regexp matches on SQLite are now faster on Ruby 2.4+, using
+  Regexp#match?.
+
+* The uniqueness validation in the validation_helpers plugin now
+  uses empty? instead of count == 0, for better performance.
+
+* On Ruby 3.4+, Sequel uses the timed_queue connection pool instead
+  of the threaded connection pool by default.  This should make it
+  so no existing applications are affected by the default switch.
+  This should hopefully allow ample testing of the timed_queue
+  connection pool.  At some point in the future, if no problems
+  are repoted, Sequel will likely switch to using the timed_queue
+  connection pool by default on Ruby 3.2+.
+
+= Backwards Compatibility
+
+* Sequel now warns by default if using eager_graph/association_join
+  with an association that uses a block, in the cases where the
+  block would be ignored and there are no appropriate graph options
+  set. In Sequel 6, this warning will be turned into an exception.
+  It is recommended that users use the auto_restrict_eager_graph
+  plugin to turn this into an exception now, or use the
+  :graph_use_association_block option so that the block is not
+  ignored when graphing.

data/doc/testing.rdoc

@@ -165,7 +165,7 @@ SEQUEL_ASYNC_THREAD_POOL_PREEMPT :: Use the async_thread_pool extension when run
 SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
 SEQUEL_CONCURRENT_EAGER_LOADING :: Use the async_thread_pool extension and concurrent_eager_loading plugin when running the specs
-SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
+SEQUEL_CONNECTION_VALIDATOR :: Use the connection_validator extension when running the adapter/integration specs
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_FIBER_CONCURRENCY :: Use the fiber_concurrency extension when running the adapter and integration specs
@@ -186,4 +186,5 @@ SEQUEL_QUERY_PER_ASSOCIATION_DB_2_URL :: Run query-per-association integration t
 SEQUEL_QUERY_PER_ASSOCIATION_DB_3_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
 SEQUEL_SPLIT_SYMBOLS :: Turn on symbol splitting when running the adapter and integration specs
 SEQUEL_SYNCHRONIZE_SQL :: Use the synchronize_sql extension when running the specs
+SEQUEL_TRANSACTION_CONNECTION_VALIDATOR :: Use the transaction_connection_validator extension when running the adapter/integration specs
 SEQUEL_TZINFO_VERSION :: Force the given tzinfo version when running the specs (e.g. '>=2')

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

@@ -145,6 +145,11 @@ module Sequel
         sqlite_version >= 30608
       end
 
+      # SQLite 3.8.2+ supports the without rowid table constraint
+      def support_without_rowid?
+        sqlite_version >= 30802
+      end
+
       # Override the default setting for whether to use timezones in timestamps.
       # It is set to +false+ by default, as SQLite's date/time methods do not
       # support timezones in timestamps.
@@ -344,9 +349,17 @@ module Sequel
         ps
       end
 
-      # Support creating STRICT tables via :strict option
+      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options
       def create_table_sql(name, generator, options)
-        "#{super}#{' STRICT' if options[:strict]}"
+        if options[:strict] && options[:without_rowid]
+          "#{super} STRICT, WITHOUT ROWID"
+        elsif options[:strict]
+          "#{super} STRICT"
+        elsif options[:without_rowid]
+          "#{super} WITHOUT ROWID"
+        else
+          super
+        end
       end
 
       # SQLite support creating temporary views.

data/lib/sequel/adapters/sqlite.rb

@@ -118,6 +118,11 @@ module Sequel
       #             it will be called with a string for the regexp and a string
       #             for the value to compare, and should return whether the regexp
       #             matches.
+      # :regexp_function_cache :: If setting +setup_regexp_function+ to +cached+, this
+      #             determines the cache to use.  It should either be a proc or a class, and it
+      #             defaults to +Hash+. You can use +ObjectSpace::WeakKeyMap+ on Ruby 3.3+ to
+      #             have the VM automatically remove regexps from the cache after they
+      #             are no longer used.
       def connect(server)
         opts = server_opts(server)
         opts[:database] = ':memory:' if blank_object?(opts[:database])
@@ -213,10 +218,23 @@ module Sequel
         when Proc
           # nothing
         when :cached, "cached"
-          cache = Hash.new{|h,k| h[k] = Regexp.new(k)}
-          how = lambda{|regexp_str, str| cache[regexp_str].match(str)}
+          cache = @opts[:regexp_function_cache] || Hash
+          cache = cache.is_a?(Proc) ? cache.call : cache.new
+          how = if RUBY_VERSION >= '2.4'
+            lambda do |regexp_str, str|
+              (cache[regexp_str] ||= Regexp.new(regexp_str)).match?(str)
+            end
+          else
+            lambda do |regexp_str, str|
+              (cache[regexp_str] ||= Regexp.new(regexp_str)).match(str)
+            end
+          end
         else
-          how = lambda{|regexp_str, str| Regexp.new(regexp_str).match(str)}
+          how = if RUBY_VERSION >= '2.4'
+            lambda{|regexp_str, str| Regexp.new(regexp_str).match?(str)}
+          else
+            lambda{|regexp_str, str| Regexp.new(regexp_str).match(str)}
+          end
         end
 
         db.create_function("regexp", 2) do |func, regexp_str, str|

data/lib/sequel/connection_pool.rb

@@ -70,8 +70,10 @@ class Sequel::ConnectionPool
       else
         pc = if opts[:single_threaded]
           opts[:servers] ? :sharded_single : :single
-        #elsif RUBY_VERSION >= '3.2' # SEQUEL6 or maybe earlier
-        #  opts[:servers] ? :sharded_timed_queue : :timed_queue
+        # :nocov:
+        elsif RUBY_VERSION >= '3.4' # SEQUEL6 or maybe earlier switch to 3.2
+          opts[:servers] ? :sharded_timed_queue : :timed_queue
+        # :nocov:
         else
           opts[:servers] ? :sharded_threaded : :threaded
         end

data/lib/sequel/database/misc.rb

@@ -263,8 +263,8 @@ module Sequel
     # Proxy the literal call to the dataset.
     #
     #   DB.literal(1)   # 1
-    #   DB.literal(:a)  # a
-    #   DB.literal('a') # 'a'
+    #   DB.literal(:a)  # "a" # or `a`, [a], or a, depending on identifier quoting
+    #   DB.literal("a") # 'a'
     def literal(v)
       schema_utility_dataset.literal(v)
     end

data/lib/sequel/database/schema_methods.rb

@@ -191,6 +191,12 @@ module Sequel
     #            The +any+ type is treated like a SQLite column in a non-strict table,
     #            allowing any type of data to be stored. This option is supported on
     #            SQLite 3.37.0+.
+    # :without_rowid :: Create a WITHOUT ROWID table. Every row in SQLite has a special
+    #                   'rowid' column, that uniquely identifies that row within the table.
+    #                   If this option is used, the 'rowid' column is omitted, which can
+    #                   sometimes provide some space and speed advantages. Note that you
+    #                   must then provide an explicit primary key when you create the table.
+    #                   This option is supported on SQLite 3.8.2+.
     #
     # See <tt>Schema::CreateTableGenerator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     def create_table(name, options=OPTS, &block)

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -14,12 +14,12 @@
 #
 #   ds = DB[:items].extension(:duplicate_columns_handler)
 #
-# A database option is introduced: :on_duplicate_columns. It accepts a Symbol
-# or any object that responds to :call.
+# If the Database option :on_duplicate_columns is set, it configures how this
+# extension works. The value should be # or any object that responds to :call.
 #
-#   on_duplicate_columns: :raise
-#   on_duplicate_columns: :warn
-#   on_duplicate_columns: :ignore
+#   on_duplicate_columns: :raise # or 'raise'
+#   on_duplicate_columns: :warn # or 'warn'
+#   on_duplicate_columns: :ignore # or anything unrecognized
 #   on_duplicate_columns: lambda{|columns| arbitrary_condition? ? :raise : :warn}
 #
 # You may also configure duplicate columns handling for a specific dataset:
@@ -30,9 +30,10 @@
 #   ds.on_duplicate_columns{|columns| arbitrary_condition? ? :raise : :warn}
 #   ds.on_duplicate_columns(lambda{|columns| arbitrary_condition? ? :raise : :warn})
 #
-# If :raise is specified, a Sequel::DuplicateColumnError is raised.
-# If :warn is specified, you will receive a warning via +warn+.
+# If :raise or 'raise' is specified, a Sequel::DuplicateColumnError is raised.
+# If :warn or 'warn' is specified, you will receive a warning via +warn+.
 # If a callable is specified, it will be called.
+# For other values, duplicate columns are ignored (Sequel's default behavior)
 # If no on_duplicate_columns is specified, the default is :warn.
 #
 # Related module: Sequel::DuplicateColumnsHandler
@@ -64,9 +65,9 @@ module Sequel
       message = "#{caller(*CALLER_ARGS).first}: One or more duplicate columns present in #{cols.inspect}"
 
       case duplicate_columns_handler_type(cols)
-      when :raise
+      when :raise, 'raise'
         raise DuplicateColumnError, message
-      when :warn
+      when :warn, 'warn'
         warn message
       end
     end

data/lib/sequel/extensions/transaction_connection_validator.rb

@@ -0,0 +1,78 @@
+# frozen-string-literal: true
+#
+# The transaction_connection_validator extension automatically
+# retries a transaction on a connection if an disconnect error
+# is raised when sending the statement to begin a new
+# transaction, as long as the user has not already checked out
+# a connection.  This is safe to do because no other queries
+# have been issued on the connection, and no user-level code
+# is run before retrying.
+#
+# This approach to connection validation can be significantly
+# lower overhead than the connection_validator extension,
+# though it does not handle all cases handled by the
+# connection_validator extension.  However, it performs the
+# validation checks on every new transaction, so it will
+# automatically handle disconnected connections in some cases
+# where the connection_validator extension will not by default
+# (as the connection_validator extension only checks
+# connections if they have not been used in the last hour by
+# default).
+#
+# Related module: Sequel::TransactionConnectionValidator
+
+#
+module Sequel
+  module TransactionConnectionValidator
+    class DisconnectRetry < DatabaseDisconnectError
+      # The connection that raised the disconnect error
+      attr_accessor :connection
+
+      # The underlying disconnect error, in case it needs to be reraised.
+      attr_accessor :database_error
+    end
+
+    # Rescue disconnect errors raised when beginning a new transaction.  If there
+    # is a disconnnect error, it should be safe to retry the transaction using a
+    # new connection, as we haven't yielded control to the user yet.
+    def transaction(opts=OPTS)
+      super
+    rescue DisconnectRetry => e
+      if synchronize(opts[:server]){|conn| conn.equal?(e.connection)}
+        # If retrying would use the same connection, that means the
+        # connection was not removed from the pool, which means the caller has
+        # already checked out the connection, and retrying will not be successful.
+        # In this case, we can only reraise the exception.
+        raise e.database_error
+      end
+
+      num_retries ||= 0 
+      num_retries += 1
+      retry if num_retries < 5
+
+      raise e.database_error
+    end
+
+    private
+
+    # Reraise disconnect errors as DisconnectRetry so they can be retried.
+    def begin_new_transaction(conn, opts)
+      super
+    rescue Sequel::DatabaseDisconnectError, *database_error_classes => e
+      if e.is_a?(Sequel::DatabaseDisconnectError) || disconnect_error?(e, OPTS)
+        exception = DisconnectRetry.new(e.message)
+        exception.set_backtrace([])
+        exception.connection = conn
+        unless e.is_a?(Sequel::DatabaseError)
+          e = Sequel.convert_exception_class(e, database_error_class(e, OPTS))
+        end
+        exception.database_error = e
+        raise exception
+      end
+
+      raise
+    end
+  end
+
+  Database.register_extension(:transaction_connection_validator, TransactionConnectionValidator)
+end

data/lib/sequel/model/associations.rb

@@ -3387,8 +3387,15 @@ module Sequel
           local_opts = ds.opts[:eager_graph][:local]
           limit_strategy = r.eager_graph_limit_strategy(local_opts[:limit_strategy])
 
-          if r[:conditions] && !Sequel.condition_specifier?(r[:conditions]) && !r[:orig_opts].has_key?(:graph_conditions) && !r[:orig_opts].has_key?(:graph_only_conditions) && !r.has_key?(:graph_block)
-            raise Error, "Cannot eager_graph association when :conditions specified and not a hash or an array of pairs.  Specify :graph_conditions, :graph_only_conditions, or :graph_block for the association.  Model: #{r[:model]}, association: #{r[:name]}"
+          # SEQUEL6: remove and integrate the auto_restrict_eager_graph plugin
+          if !r[:orig_opts].has_key?(:graph_conditions) && !r[:orig_opts].has_key?(:graph_only_conditions) && !r.has_key?(:graph_block) && !r[:allow_eager_graph]
+            if r[:conditions] && !Sequel.condition_specifier?(r[:conditions])
+              raise Error, "Cannot eager_graph association when :conditions specified and not a hash or an array of pairs.  Specify :graph_conditions, :graph_only_conditions, or :graph_block for the association.  Model: #{r[:model]}, association: #{r[:name]}"
+            end
+
+            if r[:block] && !r[:graph_use_association_block]
+              warn "eager_graph used for association when association given a block without graph options.  The block is ignored in this case.  This will result in an exception starting in Sequel 6.  Model: #{r[:model]}, association: #{r[:name]}"
+            end
           end
 
           ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>join_type || local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])

data/lib/sequel/model/base.rb

@@ -1244,18 +1244,21 @@ module Sequel
         @errors ||= errors_class.new
       end 
 
+      EXISTS_SELECT_ = SQL::AliasedExpression.new(1, :one)
+      private_constant :EXISTS_SELECT_
+
       # Returns true when current instance exists, false otherwise.
       # Generally an object that isn't new will exist unless it has
       # been deleted.  Uses a database query to check for existence,
       # unless the model object is new, in which case this is always
       # false.
       #
-      #   Artist[1].exists? # SELECT 1 FROM artists WHERE (id = 1)
+      #   Artist[1].exists? # SELECT 1 AS one FROM artists WHERE (id = 1)
       #   # => true
       #   Artist.new.exists?
       #   # => false
       def exists?
-        new? ? false : !this.get(SQL::AliasedExpression.new(1, :one)).nil?
+        new? ? false : !this.get(EXISTS_SELECT_).nil?
       end
       
       # Ignore the model's setter method cache when this instances extends a module, as the

data/lib/sequel/plugins/list.rb

@@ -185,10 +185,13 @@ module Sequel
         end
 
         # Set the value of the position_field to the maximum value plus 1 unless the
-        # position field already has a value.
+        # position field already has a value. If the list is empty, the position will
+        # be set to the model's +top_of_list+ value.
         def before_validation
           unless get_column_value(position_field)
-            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
+            current_max = list_dataset.max(position_field)
+            value = current_max.nil? ? model.top_of_list : current_max.to_i + 1
+            set_column_value("#{position_field}=", value)
           end
           super
         end

data/lib/sequel/plugins/validation_helpers.rb

@@ -295,7 +295,7 @@ module Sequel
               h = ds.joined_dataset? ? qualified_pk_hash : pk_hash
               ds = ds.exclude(h)
             end
-            errors.add(a, message) unless ds.count == 0
+            errors.add(a, message) unless ds.empty?
           end
         end
         

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 = 76
+  MINOR = 77
 
   # 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.76.0
+  version: 5.77.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-01 00:00:00.000000000 Z
+date: 2024-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -223,6 +223,7 @@ extra_rdoc_files:
 - doc/release_notes/5.74.0.txt
 - doc/release_notes/5.75.0.txt
 - doc/release_notes/5.76.0.txt
+- doc/release_notes/5.77.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 files:
@@ -327,6 +328,7 @@ files:
 - doc/release_notes/5.74.0.txt
 - doc/release_notes/5.75.0.txt
 - doc/release_notes/5.76.0.txt
+- doc/release_notes/5.77.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 - doc/schema_modification.rdoc
@@ -515,6 +517,7 @@ files:
 - lib/sequel/extensions/synchronize_sql.rb
 - lib/sequel/extensions/thread_local_timezones.rb
 - lib/sequel/extensions/to_dot.rb
+- lib/sequel/extensions/transaction_connection_validator.rb
 - lib/sequel/extensions/virtual_row_method_block.rb
 - lib/sequel/model.rb
 - lib/sequel/model/associations.rb