sequel 5.63.0 → 5.65.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abbe367cded9066a40aee5dd911a9b915f580264d00e6b668fad956bb94e38ef
-  data.tar.gz: 40ab8f35b0129177b550469f5ce9b6b6fccbcc97bdcfb3b06a2d8528bca37432
+  metadata.gz: 24bfe7c123337539140b0385dd9a828fe0fec4d6ad4e39e5fd8f150258ae7a03
+  data.tar.gz: d820be46e60ba7b08b1129f0a6b67a24a550a27d5b682a84730172bc256f4118
 SHA512:
-  metadata.gz: 87a17fc09f790b81df75fb7d170f851c9607a0f45abf6fc50c21f50243e418362fe7c804521bfe06a12e32656e234c7e79469d40d365436edad0a2e9c176a335
-  data.tar.gz: ee366f061a808d7983c2996dd969f834b74815e2a1ed77410f0bdc32f822dad72dee3c48a9ad22b6f77d791d8dc43de8bc0b4619929ac5870976495774959a7b
+  metadata.gz: bd5c7dacdf48f8ada7c34c88210ac804faa1b47741f946ca16cd6f645c1f86055eb85ac6b601e9cef2ab4aa8a5cba3dc444e3005d6ed61d324c1158f2e03a70e
+  data.tar.gz: d17eb580a3f50f4b0c33561aed320c2ea3089044b905f4dc845ea8682afe1cdbf2798c6cd202f1233b1d168d06c9686a94728d41e0f47264245a33da5a99b251

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 5.65.0 (2023-02-01)
+
+* Allow pg_auto_parameterize extension to use placeholder loaders (jeremyevans)
+
+* Do not include :min_value and :max_value schema entries for decimal/numeric columns on MySQL versions not supporting check constraints (jeremyevans)
+
+* Make Database#indexes return indexes for partitioned tables on PostgreSQL 11+ (jeremyevans)
+
+=== 5.64.0 (2023-01-01)
+
+* Make :db_type column schema entries on SQLAnywhere include precision/scale information (jeremyevans)
+
+* Include :min_value and :max_value schema entries for decimal/numeric columns on most databases (rolftimmermans, jeremyevans) (#1975)
+
+* Support :graph_use_association_block association option to make eager_graph use the association block (jeremyevans)
+
+* Make many_through_many and many_through_one associations support eager_graph callbacks (jeremyevans)
+
 === 5.63.0 (2022-12-01)
 
 * Make validates_associated plugin avoid database type errors for non-integer association keys (jeremyevans) (#1968)

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2022 Jeremy Evans
+Copyright (c) 2008-2023 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/doc/association_basics.rdoc

@@ -864,14 +864,14 @@ You can set this to +nil+ to not create a remove_all_<i>association</i> method.
 
 === :no_dataset_method
 
-Setting this to true will not result in the <i>association</i>_dataset method
+Setting this to true will result in the <i>association</i>_dataset method
 not being defined. This can save memory if you only use the <i>association</i>
 method and do not call the <i>association</i>_dataset method directly or
 indirectly.
 
 === :no_association_method
 
-Setting this to true will not result in the <i>association</i> method
+Setting this to true will result in the <i>association</i> method
 not being defined. This can save memory if you only use the
 <i>association</i>_dataset method and do not call the <i>association</i> method
 directly or indirectly.
@@ -1498,6 +1498,36 @@ as the qualifiers may not match the aliases automatically used by eager_graph.
 This should contain unqualified identifiers, and eager_graph will automatically
 qualify them with the appropriate alias.
 
+==== :graph_use_association_block
+
+Setting this to true makes eager_graph apply the association block to the
+associated dataset before graphing the associated dataset into the receiver.
+In most cases when this option is used and the association has a block, the
+dataset returned by eager_graph will contain a JOIN to a subquery.
+
+By default (when this option is not used), the association block will be ignored
+when using eager_graph:
+
+  Artist.one_to_many :tracks do |ds|
+    ds.where(foo: 3)
+  end
+  Artist.eager_graph(:tracks)
+  # SELECT albums.id, tracks.id AS tracks_id, tracks.album_id
+  # FROM albums
+  # LEFT OUTER JOIN tracks
+  # ON (tracks.album_id = albums.id)
+
+When this option is used, the block will be respected:
+
+  Artist.one_to_many :tracks, graph_use_association_block: true do |ds|
+    ds.where(foo: 3)
+  end
+  Artist.eager_graph(:tracks)
+  # SELECT albums.id, tracks.id AS tracks_id, tracks.album_id
+  # FROM albums
+  # LEFT OUTER JOIN (SELECT * FROM tracks WHERE (foo = 3)) AS tracks
+  # ON (tracks.album_id = albums.id)
+
 ==== :graph_join_table_conditions [+many_to_many+, +one_through_one+]
 
 The additional conditions to use on the SQL join for the join table when

data/doc/release_notes/5.64.0.txt

@@ -0,0 +1,50 @@
+= New Features
+
+* A :graph_use_association_block association option has been added,
+  which makes eager_graph use the association block (as eager does),
+  generally resulting in a JOIN to a subquery:
+
+    Artist.one_to_many :tracks, graph_use_association_block: true do |ds|
+      ds.where(foo: 3)
+    end
+    Artist.eager_graph(:tracks)
+    # SELECT albums.id, tracks.id AS tracks_id, tracks.album_id
+    # FROM albums
+    # LEFT OUTER JOIN (SELECT * FROM tracks WHERE (foo = 3)) AS tracks
+    # ON (tracks.album_id = albums.id)
+
+  Assuming that the database can optimize the query correctly, using
+  the :graph_use_association_block option is probably simpler than
+  than using other :graph_* options to duplicate the conditions added
+  by the association block.
+
+* Numeric/Decimal column schema entries now include :min_value and
+  :max_value entries on most databases, indicating the minimum and
+  maximum values supported for the column. Similar to the support
+  for integer columns added in 5.62.0, this allows the
+  auto_validations plugin to automatically validate the values of
+  the columns are in the allowed range.
+
+= Other Improvements
+
+* many_through_{one,many} associations now support eager_graph
+  callbacks.
+
+* The :db_type column schema entries on SQLAnywhere now include
+  precision/scale information, to work with the numeric/decimal
+  column min_value/max_value support.
+
+* The oracle adapter now includes a :column_size column schema
+  entry containing the precision of the columns, to work with the
+  numeric/decimal column min_value/max_value support.
+
+= Backwards Compatibility
+
+* The private Database#column_schema_integer_min_max_values method
+  added in 5.62.0 now takes a column schema hash instead of a
+  database type string.
+
+* Code that previously looked at the :db_type column schema entry on
+  SQLAnywhere should be updated to look at the :domain_name entry, and
+  code that looked at the :domain_name_with_size entry should be
+  updated to look at the :db_type entry.

data/doc/release_notes/5.65.0.txt

@@ -0,0 +1,21 @@
+= Improvements
+
+* The pg_auto_parameterize extension now uses a modified placeholder
+  literalizer for speeding up the generation of SQL queries in the same
+  cases where a standard dataset would use a placeholder literalizer.
+  This can provide a 4% speedup for simple queries, with greater
+  speedups for more complex queries.
+
+* Database#indexes now returns indexes for partitioned tables on
+  PostgreSQL 11+.
+
+* MySQL versions not supporting CHECK constraints no longer include
+  :min_value/:max_value schema entries for decimal/numeric columns.
+
+= Backwards Compatibility
+
+* The Dataset::PlaceholderLiterlizer::Record.loader API has changed,
+  it now accepts the Dataset::PlaceholderLiterlizer class to use as
+  the first argument.  This makes it easier to create
+  Dataset::PlaceholderLiterlizer subclasses, such as the one now used
+  by the pg_auto_parameterize extension.

data/doc/sql.rdoc

@@ -59,7 +59,7 @@ Then, you call the +insert+, +update+, or +delete+ method on the returned datase
   update_ds.update
   delete_ds.delete
 
-+update+ and +delete+ should return the number of rows affected, and +insert+ should return the autogenerated primary key integer for the row inserted (if any).
++update+ and +delete+ generally return the number of rows affected, and +insert+ generally returns the autogenerated primary key integer for the row inserted (if any), but not all adapters/databases support this behavior for datasets using custom SQL (notably it is not supported for +insert+ on PostgreSQL).
 
 === Other Queries
 

data/lib/sequel/adapters/oracle.rb

@@ -312,6 +312,7 @@ module Sequel
               :char_used => column.char_used?,
               :char_size => column.char_size,
               :data_size => column.data_size,
+              :column_size => column.precision,
               :precision => column.precision,
               :scale => column.scale,
               :fsprecision => column.fsprecision,

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

@@ -60,8 +60,8 @@ module Sequel
       # Access's Byte type will accept much larger values,
       # even though it only stores 0-255.  Do not set min/max
       # values for the Byte type.
-      def column_schema_integer_min_max_values(db_type)
-        return if /byte/i =~ db_type
+      def column_schema_integer_min_max_values(column)
+        return if /byte/i =~ column[:db_type]
         super
       end
 

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

@@ -553,7 +553,14 @@ module Sequel
       # Return nil if CHECK constraints are not supported, because
       # versions that don't support check constraints don't raise
       # errors for values outside of range.
-      def column_schema_integer_min_max_values(db_type)
+      def column_schema_integer_min_max_values(column)
+        super if supports_check_constraints?
+      end
+
+      # Return nil if CHECK constraints are not supported, because
+      # versions that don't support check constraints don't raise
+      # errors for values outside of range.
+      def column_schema_decimal_min_max_values(column)
         super if supports_check_constraints?
       end
 

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

@@ -178,11 +178,11 @@ module Sequel
         ''
       end
 
-      # Do not support min/max integer values on Oracle, since
-      # Oracle uses a number type, and integer just adds a
-      # constaint on the number type.
-      def column_schema_integer_min_max_values(db_type)
-        nil
+      # Support min/max integer values on Oracle only if
+      # they use a NUMBER column with a fixed precision
+      # and no scale.
+      def column_schema_integer_min_max_values(column)
+        super if column[:db_type] =~ /NUMBER\(\d+\)/i || (column[:db_type] == 'NUMBER' && column[:column_size].is_a?(Integer) && column[:scale] == 0)
       end
 
       def create_sequence_sql(name, opts=OPTS)

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

@@ -919,7 +919,7 @@ module Sequel
             join(Sequel[:pg_attribute].as(:att), :attrelid=>Sequel[:tab][:oid], :attnum=>attnums).
             left_join(Sequel[:pg_constraint].as(:con), :conname=>Sequel[:indc][:relname]).
             where{{
-              indc[:relkind]=>'i',
+              indc[:relkind]=>%w'i I',
               ind[:indisprimary]=>false,
               :indexprs=>nil,
               :indisvalid=>true}}.

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

@@ -37,7 +37,7 @@ module Sequel
           row[:auto_increment] = auto_increment == 1 || auto_increment == true
           row[:primary_key] = row.delete(:pkey) == 'Y'
           row[:allow_null] = row[:nulls_allowed].is_a?(Integer) ? row.delete(:nulls_allowed) == 1 : row.delete(:nulls_allowed)
-          row[:db_type] = row.delete(:domain_name)
+          row[:db_type] = row.delete(:domain_name_with_size)
           row[:type] = if row[:db_type] =~ /numeric/i and (row[:scale].is_a?(Integer) ? row[:scale] == 0 : !row[:scale])
             :integer
           else

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

@@ -320,10 +320,11 @@ module Sequel
         end
       end
     
-      # SQLite does not restrict the integer type to a specific range.
-      def column_schema_integer_min_max_values(db_type)
+      # SQLite does not restrict the integer or decimal type to a specific range.
+      def column_schema_integer_min_max_values(column)
         nil
       end
+      alias column_schema_decimal_min_max_values column_schema_integer_min_max_values
 
       # Array of PRAGMA SQL statements based on the Database options that should be applied to
       # new connections.

data/lib/sequel/database/query.rb

@@ -175,8 +175,14 @@ module Sequel
         if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
           c[:max_length] = max_length
         end
-        if !c[:max_value] && !c[:min_value] && c[:type] == :integer && (min_max = column_schema_integer_min_max_values(c[:db_type]))
-          c[:min_value], c[:max_value] = min_max
+        if !c[:max_value] && !c[:min_value]
+          min_max = case c[:type]
+          when :integer
+            column_schema_integer_min_max_values(c)
+          when :decimal
+            column_schema_decimal_min_max_values(c)
+          end
+          c[:min_value], c[:max_value] = min_max if min_max
         end
       end
       schema_post_process(cols)
@@ -288,7 +294,15 @@ module Sequel
 
     # Look at the db_type and guess the minimum and maximum integer values for
     # the column.
-    def column_schema_integer_min_max_values(db_type)
+    def column_schema_integer_min_max_values(column)
+      db_type = column[:db_type]
+      if /decimal|numeric|number/i =~ db_type
+        if min_max = column_schema_decimal_min_max_values(column)
+          min_max.map!(&:to_i)
+        end
+        return min_max
+      end
+
       unsigned = /unsigned/i =~ db_type
       case db_type
       when /big|int8/i
@@ -304,6 +318,26 @@ module Sequel
       end
     end
 
+    # Look at the db_type and guess the minimum and maximum decimal values for
+    # the column.
+    def column_schema_decimal_min_max_values(column)
+      if column[:column_size] && column[:scale]
+        precision = column[:column_size]
+        scale = column[:scale]
+      elsif /\((\d+)(?:,\s*(-?\d+))?\)/ =~ column[:db_type]
+        precision = $1.to_i
+        scale = $2.to_i if $2
+      end
+
+      if precision
+        limit = BigDecimal("9" * precision)
+        if scale
+          limit /= 10**(scale)
+        end
+        [-limit, limit]
+      end
+    end
+
     # Whether the tinyint type (if supported by the database) is unsigned by default.
     def column_schema_tinyint_type_is_unsigned?
       false
@@ -370,7 +404,7 @@ module Sequel
         :boolean
       when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
         :float
-      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?))\z/io
+      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(-?\d+|false|true)\))?))\z/io
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal
       when /bytea|blob|image|(var)?binary/io
         :blob

data/lib/sequel/dataset/misc.rb

@@ -158,6 +158,16 @@ module Sequel
      !!((opts[:from].is_a?(Array) && opts[:from].size > 1) || opts[:join])
     end
 
+    # The class to use for placeholder literalizers for the current dataset.
+    def placeholder_literalizer_class
+      ::Sequel::Dataset::PlaceholderLiteralizer
+    end
+
+    # A placeholder literalizer loader for the current dataset.
+    def placeholder_literalizer_loader(&block)
+      placeholder_literalizer_class.loader(self, &block)
+    end
+
     # The alias to use for the row_number column, used when emulating OFFSET
     # support and for eager limit strategies
     def row_number_column
@@ -296,7 +306,7 @@ module Sequel
         loader += 1
 
         if loader >= 3
-          loader = Sequel::Dataset::PlaceholderLiteralizer.loader(self){|pl, _| yield pl}
+          loader = placeholder_literalizer_loader{|pl, _| yield pl}
           cache_set(key, loader)
         else
           cache_set(key, loader + 1)

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -77,8 +77,8 @@ module Sequel
         # Yields the receiver and the dataset to the block, which should
         # call #arg on the receiver for each placeholder argument, and
         # return the dataset that you want to load.
-        def loader(dataset, &block)
-          PlaceholderLiteralizer.new(*process(dataset, &block))
+        def loader(pl, dataset, &block)
+          pl.new(*process(dataset, &block))
         end
 
         # Return an Argument with the specified position, or the next position. In
@@ -145,7 +145,7 @@ module Sequel
       # given block, recording the offsets at which the recorders arguments
       # are used in the query.
       def self.loader(dataset, &block)
-        Recorder.new.loader(dataset, &block)
+        Recorder.new.loader(self, dataset, &block)
       end
 
       # Save the dataset, array of SQL fragments, and ending SQL string.
@@ -199,20 +199,31 @@ module Sequel
       # Return the SQL query to use for the given arguments.
       def sql(*args)
         raise Error, "wrong number of arguments (#{args.length} for #{@arity})" unless args.length == @arity
-        s = String.new
+        s = sql_origin
+        append_sql(s, *args)
+      end
+
+      # Append the SQL query to use for the given arguments to the given SQL string.
+      def append_sql(sql, *args)
         ds = @dataset
-        @fragments.each do |sql, i, transformer|
-          s << sql
+        @fragments.each do |s, i, transformer|
+          sql << s
           if i.is_a?(Integer)
             v = args.fetch(i)
             v = transformer.call(v) if transformer
           else
             v = i.call
           end
-          ds.literal_append(s, v)
+          ds.literal_append(sql, v)
         end
-        s << @final_sql
-        s
+        sql << @final_sql
+        sql
+      end
+
+      private
+
+      def sql_origin
+        String.new
       end
     end
   end

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -148,7 +148,10 @@ module Sequel
 
         # Freeze the stored arguments when freezing the query string.
         def freeze
-          @args.freeze if @args
+          if @args
+            @args.freeze
+            @arg_map.freeze
+          end
           super
         end
 
@@ -156,6 +159,14 @@ module Sequel
         def inspect
           @args ? "#{self}; #{@args.inspect}".inspect : super
         end
+
+        def initialize_copy(other)
+          super
+          if args = other.instance_variable_get(:@args)
+            @args = args.dup
+            @arg_map = other.instance_variable_get(:@arg_map).dup
+          end
+        end
       end
 
       # Wrapper class that skips auto parameterization for the wrapped object.
@@ -169,6 +180,22 @@ module Sequel
         end
       end
 
+      # PlacholderLiteralizer subclass with support for stored auto parameters.
+      class PlaceholderLiteralizer < ::Sequel::Dataset::PlaceholderLiteralizer
+        def initialize(dataset, fragments, final_sql, arity)
+          s = dataset.sql.dup
+          s.clear
+          @sql_origin = s.freeze
+          super
+        end
+
+        private
+
+        def sql_origin
+          @sql_origin.dup
+        end
+      end
+
       module DatabaseMethods
         def self.extended(db)
           unless (db.adapter_scheme == :postgres && USES_PG) || (db.adapter_scheme == :mock && db.database_type == :postgres)
@@ -282,9 +309,13 @@ module Sequel
           end
         end
 
-        # Placeholder literalizers are not supported supported when using automatic parameterization.
-        def supports_placeholder_literalizer?
-          @opts[:no_auto_parameterize]
+        # The class to use for placeholder literalizers.
+        def placeholder_literalizer_class
+          if @opts[:no_auto_parameterize]
+            super
+          else
+            PlaceholderLiteralizer
+          end
         end
 
         # Disable automatic parameterization when using a cursor.

data/lib/sequel/model/associations.rb

@@ -310,7 +310,17 @@ module Sequel
             loader = union_eager_loader
             joiner = " UNION ALL "
             ids.each_slice(subqueries_per_union).each do |slice|
-              objects.concat(ds.with_sql(slice.map{|k| loader.sql(*k)}.join(joiner)).to_a)
+              sql = loader.send(:sql_origin)
+              join = false
+              slice.each do |k|
+                if join
+                  sql << joiner
+                else
+                  join = true
+                end
+                loader.append_sql(sql, *k)
+              end
+              objects.concat(ds.with_sql(sql).to_a)
             end
             ds = ds.eager(cascade) if cascade
             ds.send(:post_load, objects)
@@ -446,7 +456,7 @@ module Sequel
         def placeholder_loader
           if use_placeholder_loader?
             cached_fetch(:placeholder_loader) do
-              Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
+              associated_dataset.placeholder_literalizer_loader do |pl, ds|
                 ds = ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
                 if self[:block]
                   ds = self[:block].call(ds)
@@ -748,8 +758,8 @@ module Sequel
         # A placeholder literalizer used to speed up eager loading.
         def placeholder_eager_loader
           cached_fetch(:placeholder_eager_loader) do
-            Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
-              apply_eager_limit_strategy(eager_loading_dataset.where(predicate_key=>pl.arg), eager_limit_strategy)
+            eager_loading_dataset.placeholder_literalizer_loader do |pl, ds|
+              apply_eager_limit_strategy(ds.where(predicate_key=>pl.arg), eager_limit_strategy)
             end
           end
         end
@@ -808,7 +818,7 @@ module Sequel
         # loading a limited association.
         def union_eager_loader
           cached_fetch(:union_eager_loader) do
-            Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
+            associated_dataset.placeholder_literalizer_loader do |pl, ds|
               ds = self[:eager_block].call(ds) if self[:eager_block]
               keys = predicate_keys
               ds = ds.where(keys.map{pl.arg}.zip(keys))
@@ -1722,6 +1732,8 @@ module Sequel
         # :graph_select :: A column or array of columns to select from the associated table
         #                  when eagerly loading the association via +eager_graph+. Defaults to all
         #                  columns in the associated table.
+        # :graph_use_association_block :: Makes eager_graph consider the association block. Without this, eager_graph
+        #                                 ignores the bock and only use the :graph_* options.
         # :instance_specific :: Marks the association as instance specific. Should be used if the association block
         #                       uses instance specific state, or transient state (accessing current date/time, etc.).
         # :limit :: Limit the number of records to the provided value.  Use
@@ -2461,6 +2473,9 @@ module Sequel
         # Return dataset to graph into given the association reflection, applying the :callback option if set.
         def eager_graph_dataset(opts, eager_options)
           ds = opts.associated_class.dataset
+          if opts[:graph_use_association_block] && (b = opts[:block])
+            ds = b.call(ds)
+          end
           if cb = eager_options[:callback]
             ds = cb.call(ds)
           end

data/lib/sequel/plugins/finder.rb

@@ -151,7 +151,7 @@ module Sequel
                 ds
               end
 
-              Sequel::Dataset::PlaceholderLiteralizer.loader(model, &block) 
+              model.dataset.placeholder_literalizer_class.loader(model, &block) 
             end
           end
 

data/lib/sequel/plugins/many_through_many.rb

@@ -385,7 +385,7 @@ module Sequel
                 iq = nil
               end
               fe = opts.final_edge
-              ds.graph(opts.associated_class.dataset, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
+              ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
             end
           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 = 63
+  MINOR = 65
 
   # 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.63.0
+  version: 5.65.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-01 00:00:00.000000000 Z
+date: 2023-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -195,6 +195,8 @@ extra_rdoc_files:
 - doc/release_notes/5.61.0.txt
 - doc/release_notes/5.62.0.txt
 - doc/release_notes/5.63.0.txt
+- doc/release_notes/5.64.0.txt
+- doc/release_notes/5.65.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -286,6 +288,8 @@ files:
 - doc/release_notes/5.61.0.txt
 - doc/release_notes/5.62.0.txt
 - doc/release_notes/5.63.0.txt
+- doc/release_notes/5.64.0.txt
+- doc/release_notes/5.65.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -609,7 +613,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: The Database Toolkit for Ruby