sequel 4.36.0 → 5.61.0

data/doc/release_notes/5.5.0.txt

@@ -0,0 +1,61 @@
+= New Features
+
+* The defaults_setter plugin now supports a :cache option, which
+  will cache default values in the model object's values hash:
+
+    Model.plugin :defaults_setter
+    o = Model.new
+    o.column # => 1 # default value
+    o.values # => {}
+
+    Model.plugin :defaults_setter, cache: true
+    o = Model.new
+    o.column # => 1 # default value
+    o.values # => {:column => 1}
+
+* The pg_array extension now sets a :callable_default schema entry
+  for recognized empty array defaults.
+
+* The pg_hstore extension now sets a :callable_default schema entry
+  for recognized empty hstore defaults.
+
+* The pg_json extension now sets a :callable_default schema entry for
+  recognized empty json/jsonb array/hash defaults. 
+
+* The pg_inet extension now sets a :ruby_default schema entry for
+  recognized inet/cidr defaults.
+
+* The pg_range extension now sets a :ruby_default schema entry for
+  recognized range defaults.
+
+* The defaults_setter plugin will now give preference to a
+  :callable_default schema entry over a :ruby_default schema entry.
+  Combined with the other changes listed above, this makes default
+  values recognized by the pg_array, pg_hstore, and pg_json extensions
+  work well if the defaults_setter :cache option is also used.
+
+= Other Improvements
+
+* The modification_detection plugin no longer breaks column change
+  detection for new objects.
+
+* Database#copy_table in the postgres adapter now handles errors that
+  occur when processing rows.  Previously, an exception could be
+  raised on the next query in that case.
+
+* The results of the changed_columns method are now cached in many
+  places internally where they are called in a loop.  This results
+  in better performance, especially if the modification_detection or
+  serialization_modification_detection plugins are used.
+
+= Backwards Compatibility
+
+* The pg_interval extension now sets a :ruby_default schema entry for
+  recognized interval defaults to the same value Sequel would return
+  if the default value was returned.  Previously, Sequel would use a
+  string in the :ruby_schema schema value.
+
+* String values in hashes returned by Database#schema are now frozen
+  to prevent possible thread-safety issues and issues with
+  unintentional modification of a shared string.  The hashes
+  themselves are not frozen and can still be modified.

data/doc/release_notes/5.50.0.txt

@@ -0,0 +1,78 @@
+= New Features
+
+* A pg_multirange extension has been added with support for PostgreSQL
+  14+ multirange types.  Multirange types are similar to an array of
+  ranges, where a value is in the multirange if it is in any of the
+  ranges contained in the multirange. Multiranges are useful when you
+  need to check against multiple ranges that do not overlap.
+
+  You can create multiranges using Sequel.pg_multirange, passing
+  an array of ranges and a multirange type:
+
+    DB.extension :pg_multirange
+    multirange = Sequel.pg_multirange(array_of_date_ranges, :datemultirange)
+
+  Sequel.pg_multirange returns a PGMultiRange, which operates as a
+  delegate to an array of PGRange objects.  Behavior of the object
+  is similar to an array, except that cover? is supported, which will
+  test if any of the included ranges covers the argument:
+
+    multirange.cover?(Date.today)
+
+  Like the pg_range extension, this also supports registering custom
+  multirange types, and using multirange types as bound variables.
+
+  The pg_range_ops extension now supports both ranges and multiranges,
+  with a few new methods added to Postgres::RangeOp for converting
+  between them:
+
+  * range_merge
+  * multirange
+  * and unnest
+
+* An sql_log_normalizer extension has been added for normalizing
+  logged SQL, replacing numbers and strings inside the SQL string
+  with question marks.  This is useful for analytics and sensitive
+  data.
+
+    DB[:table].first(a: 1, b: 'something')
+    # Without sql_log_normalizer extension, logged SQL is:
+    # SELECT * FROM "table" WHERE (("a" = 1) AND ("b" = 'something')) LIMIT 1
+
+    DB.extension :sql_log_normalizer
+    DB[:table].first(a: 1, b: 'something')
+    # With sql_log_normalizer_extension, logged SQL is:
+    # SELECT * FROM "table" WHERE (("a" = ?) AND ("b" = ?)) LIMIT ?
+
+  This extension scans the logged SQL for numbers and strings,
+  attempting to support the database's rules for string quoting.  This
+  means it should work with SQL that Sequel didn't itself create.
+  However, there are corner cases that the extension doesn't handle,
+  such as the use of apostrophes inside quoted identifiers, and
+  potentially other cases of database specific SQL where the normal
+  string quoting rules are changed, such as the use of escape strings
+  on PostgreSQL (E'escape string').
+
+* A :before_preconnect Database option has been added.  This is useful
+  for configuring extensions added via :preconnect_extensions before
+  the connection takes place.
+
+= Other Improvements
+
+* Dataset#columns! now uses a LIMIT 0 query instead of a LIMIT 1 query
+  by default. This can improve performance in cases where the row
+  returned would be large.  Some databases do not support a LIMIT 0
+  query, and some adapters that ship with Sequel have been updated to
+  continue using LIMIT 1.  Custom adapters should be updated to use
+  LIMIT 1 if the database does not support LIMIT 0.
+
+* The lazy_attributes plugin no longer modifies the database schema.
+  Previously, it could modify the database schema indirectly,
+  resulting in the loss of typecasting for models that were not
+  based on a single table or view, such as usage with the
+  class_table_inheritance plugin.
+
+* Model#freeze in the composition, serialization, and
+  serialization_modification_detection plugins now returns self. In
+  addition to being more correct, this fixes usage of these plugins
+  with the static_cache plugin.

data/doc/release_notes/5.51.0.txt

@@ -0,0 +1,47 @@
+= New Features
+
+* On PostgreSQL 14+, Dataset#with_recursive now supports :search and
+  :cycle options for result ordering and cycle detection.  These use
+  the SEARCH and CYCLE clauses added in PostgreSQL 14:
+
+    DB[:t].with_recursive(:t,
+      DB[:i1].where(parent_id: nil),
+      DB[:i1].join(:t, id: :parent_id).select_all(:i1),
+      search: {by: :id, type: :breadth},
+      cycle: {columns: :id, cycle_value: 1, noncycle_value: 2})
+
+    # WITH RECURSIVE t AS (
+    #     SELECT * FROM i1 WHERE (parent_id IS NULL)
+    #     UNION ALL
+    #     (SELECT i1.* FROM i1 INNER JOIN t ON (t.id = i1.parent_id))
+    #   )
+    #   SEARCH BREADTH FIRST BY id SET ordercol
+    #   CYCLE id SET is_cycle TO 1 DEFAULT 2 USING path
+
+* On MySQL, column schema hashes now contain an :extra entry, which
+  contains the Extra string returned in MySQL's DESCRIBE results
+  for the column.
+
+= Other Improvements
+
+* When eager loading via the tactical_eager_loading plugin, objects
+  that already have an association loaded will not have it reloaded
+  unless the :eager_reload option is given.
+
+* When cloning an association and using a different :class option
+  than the cloned association, the :class option given when cloning
+  will now take precedence over the :class option for the cloned
+  association.
+
+* When using the mock postgres adapter, the adapter defaults to
+  supporting PostgreSQL 14 (previously, it defaulted to supporting
+  PostgreSQL 9.5).
+
+* Sequel now avoids a method redefined warning in the lazy attributes
+  plugin in verbose warnings mode.
+
+= Other
+
+* Sequel's primary discussion forum is now GitHub Discussions. The
+  sequel-talk Google Group is still available for users who would
+  prefer to use that instead.

data/doc/release_notes/5.52.0.txt

@@ -0,0 +1,87 @@
+= New Features
+
+* When the sql_comments Database extension is used,
+  Database#with_comments is now added, which can be used for including
+  comments for all queries executed inside a given block.  This can
+  be useful if you want to analyze database query logs, and want to
+  group all related queries:
+
+     DB.with_comments(model: Album, action: :all) do
+       DB[:albums].all
+       # SELECT * FROM albums -- model:Album,action:all
+    end
+
+* An sql_comments plugin has been added, which will automatically
+  add SQL comments for all queries generated by model class, instance
+  and dataset methods:
+
+    Album.plugin :sql_comments
+
+    album = Album[1]
+    # SELECT * FROM albums WHERE (id = 1) LIMIT 1
+    # -- model:Album,method_type:class,method:[]
+
+    album.update(:name=>'A')
+    # UPDATE albums SET name = 'baz' WHERE (id = 1)
+    # -- model:Album,method_type:instance,method:update
+
+    Album.where(id: 1).delete
+    # DELETE FROM albums WHERE (id = 1)
+    # -- model:Album,method_type:dataset,method:delete
+
+  This plugin requires you have loaded the sql_comments Database
+  extension into the related Database before use.
+
+* A date_parse_input_handler extension has been added to support
+  custom handling of input to date parsing methods.  Among other
+  things, you can use this to limit the length of strings that
+  will be parsed, which can prevent ArgumentErrors in newer Ruby
+  versions:
+
+    Sequel.extension :date_parse_input_handler
+    Sequel.date_parse_input_handler do |string|
+      string.b[0, 128]
+    end
+
+= Other Improvements
+
+* On Ruby 3.1, the core_refinements extension now avoids the
+  deprecated Refinement#include, switching to
+  Refinement#import_methods.
+
+* On Ruby 3.1, the subclasses plugin will use Ruby's native support
+  for Class#subclasses.
+
+* The subclasses plugin has renamed descendents to descendants and
+  freeze_descendents to freeze_descendants.  The previous method
+  names are still available as aliases.
+
+* The :ruby_default schema entry for datetime/timestamp columns now
+  respects Sequel.datetime_class.  Previously, the value for the
+  :ruby_default schema entry would always be a DateTime value for
+  such columns.
+
+* The pg_interval extension now works with ActiveSupport 7.0.
+
+* The shared postgres adapter now respects
+  Database#default_string_column_size for setting the size of string
+  columns that don't use text as the database type.
+
+* Database#supports_check_constraints? now returns true on MySQL
+  8.0.19+. This fixes drop_constraint in certain cases when combining
+  the constraint dropping with other changes in the same alter_table
+  block.
+
+* The mysql adapter now supports the ruby-mysql 3 API (ruby-mysql
+  is a pure-ruby MySQL driver).
+
+* The mysql adapter no longer uses the connection's server_version
+  method if it is defined, as the method does not return the
+  correct value when using the ruby-mysql driver with MariaDB.
+
+* Comments added by the sql_comments extension no longer modify
+  cached SQL for a dataset.
+
+= Other
+
+* This is Sequel's 250th release!

data/doc/release_notes/5.53.0.txt

@@ -0,0 +1,23 @@
+= Improvements
+
+* The jdbc/h2 subadapter now supports H2 version 2.0.  It continues to
+  support H2 versions 1.3 and 1.4.
+
+* The mysql2 adapter's prepared statement support now reuses existing
+  native prepared statements, instead of only binding variables on
+  newly prepared statements.  This was the intended behavior
+  previously, and should result in increased performance in cases
+  where preparing a query takes significant time.
+
+* The subclasses plugin now ignores an existing Class#subclasses
+  method if it is defined in Ruby.  This fixes cases where usage of
+  ActiveSupport would break the subclasses plugin.
+
+* Database#call_sproc in the jdbc adapter will now always close the
+  prepared call it creates.  Before, if there was an exception raised
+  when setting the arguments for the prepared call, the prepared call
+  would not be closed.
+
+* A more appropriate error is now issued if you try to use the
+  column_encryption plugin to encrypt a column without setting up an
+  encryption key.

data/doc/release_notes/5.54.0.txt

@@ -0,0 +1,27 @@
+= New Feature
+
+* An enum plugin has been added.  This plugin allows you to create
+  model-level enums, giving names to underlying values of a column.
+  For example:
+
+    Album.plugin :enum
+    Album.enum :status_id, good: 1, bad: 2
+
+  Adds Album#good! and Album#bad! for changing the status_id to 1 or 
+  2 respectively.  It adds Album#good? and Album#bad? for checking
+  whether the status_id is 1 or 2 respectively.  It overrides
+  Album#status_id to return :good or :bad instead of 1 or 2,
+  respectively, and overrides Album#status_id= to accept :good or
+  :bad instead of 1 or 2 respectively.
+
+  Additionally, it adds good and bad dataset methods for filtering
+  the model's dataset to records where status_id is 1 or 2
+  respectively. It also adds not_good and not_bad dataset methods
+  for filtering the model's dataset to records where status_id is not
+  1 or not 2 respectively.
+
+  You can use :prefix and :suffix options when calling enum to
+  add a prefix or suffix to the method names created.  You can
+  set the :override_accessors option to false to not override
+  the accessor methods for the column, and set the :dataset_methods
+  option to false to not add dataset methods.

data/doc/release_notes/5.55.0.txt

@@ -0,0 +1,21 @@
+= New Features
+
+* An auto_restrict_eager_graph plugin has been added for automatically
+  disallowing the use of eager_graph with associations using blocks but
+  lacking graph_* options.  This can prevent potentionally invalid usage,
+  as the restrictions added by the block are not used by eager_graph.
+
+* The sqlite adapter now supports the :setup_regexp_function
+  Database option. This option will define a REGEXP function in the
+  database that will allow regexp support in queries, such as:
+
+    DB[:table].where(column: /(some|pattern)/)
+
+  Note that this creates a Ruby Regexp object per column value tested,
+  so it isn't the most optimal approach. 
+
+= Other Improvements
+
+* Calling dataset aggregate methods such as #max on a model dataset now
+  works correctly. Previously, it could fail if called enough times to
+  optimize using a placeholder literalizer.

data/doc/release_notes/5.56.0.txt

@@ -0,0 +1,51 @@
+= New Features
+
+* On SQLite, Database#create_table now supports a :strict option to
+  use the STRICT keyword when creating the table.  When this option
+  is used, SQLite will enforce the types for each column. When using
+  this option, you are limited to using the following column types:
+  int, integer, real, text, blob, and any (any allows for dynamic
+  types).
+
+* An sqlite_json_ops extension has been added, providing DSL support
+  for JSON functions and operators supported in SQLite 3.38.0. Usage
+  is similar to the pg_json_ops extension.  First, you create an
+  appropriate object:
+
+    j = Sequel.sqlite_json_op(:json_column)
+    # or:
+    j = Sequel[:json_column].sqlite_json_op
+
+  Then, you call methods on that object to create expressions for the
+  JSON functions and operators:
+
+    j[1]                 # (json_column ->> 1)
+    j.get_text(1)        # (json_column -> 1)
+    j.extract('$.a')     # json_extract(json_column, '$.a')
+ 
+    j.array_length       # json_array_length(json_column)
+    j.type               # json_type(json_column)
+    j.valid              # json_valid(json_column)
+    j.json               # json(json_column)
+ 
+    j.insert('$.a', 1)   # json_insert(json_column, '$.a', 1)
+    j.set('$.a', 1)      # json_set(json_column, '$.a', 1)
+    j.replace('$.a', 1)  # json_replace(json_column, '$.a', 1)
+    j.remove('$.a')      # json_remove(json_column, '$.a')
+    j.patch('{"a":2}')   # json_patch(json_column, '{"a":2}')
+ 
+    j.each               # json_each(json_column)
+    j.tree               # json_tree(json_column)
+
+= Other Improvements
+
+* The alter_table add_column and add_foreign_key methods now support
+  the :index option to create an index on the added column, for
+  compatibility with the :index option on the create_table column and
+  foreign_key methods.
+
+* The schema_dumper extension now treats the "INTEGER" type the same
+  as the "integer" type.  This fixes some behavior when using SQLite
+  3.37.0+.
+
+* Sequel's website has a much improved visual design.

data/doc/release_notes/5.57.0.txt

@@ -0,0 +1,23 @@
+= New Features
+
+* An is_distinct_from extension has been added with support for the
+  SQL IS DISTINCT FROM operator.  This operator is similar to the
+  not equals operator, except in terms of NULL handling.  It returns
+  true if only one side is NULL, and false if both sides are NULL.
+  You can call is_distinct_from on Sequel itself or on Sequel objects:
+
+    Sequel.is_distinct_from(:column_a, :column_b)
+    Sequel[:column_a].is_distinct_from(:column_b)
+    # (column_a IS DISTINCT FROM column_b)
+
+  On databases not supporting IS DISTINCT FROM, support is emulated
+  using a CASE statement.
+
+* Column definitions on MySQL can use the :on_update_current_timestamp
+  option for ON UPDATE CURRENT_TIMESTAMP, which creates a column that
+  will automatically have its value set to CURRENT_TIMESTAMP on every
+  update.
+
+* Database#create_function on PostgreSQL now supports a :parallel
+  option to set the thread safety of the funciton.  The value should
+  be :safe, :unsafe, or :restricted.

data/doc/release_notes/5.58.0.txt

@@ -0,0 +1,31 @@
+= New Features
+
+* Dataset#merge and related #merge_* methods have been added for the
+  MERGE statement.  MERGE is supported on PostgreSQL 15+, Oracle,
+  Microsoft SQL Server, DB2, H2, HSQLDB, and Derby. You can use MERGE
+  to insert, update, and/or delete in a single query.  You call
+  the #merge_* methods to setup the MERGE statement, and #merge to
+  execute it on the database:
+
+    ds = DB[:m1]
+      merge_using(:m2, i1: :i2).
+      merge_insert(i1: :i2, a: Sequel[:b]+11).
+      merge_delete{a > 30}.
+      merge_update(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+
+    ds.merge
+    # MERGE INTO m1 USING m2 ON (i1 = i2)
+    # WHEN NOT MATCHED THEN INSERT (i1, a) VALUES (i2, (b + 11))
+    # WHEN MATCHED AND (a > 30) THEN DELETE
+    # WHEN MATCHED THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+
+  On PostgreSQL, the following additional MERGE related methods are
+  available:
+
+  * #merge_do_nothing_when_matched
+  * #merge_do_nothing_when_not_matched
+
+* A :disable_split_materialized Database option is now supported on
+  MySQL. This disables split_materialized support in the optimizer,
+  working around a bug in MariaDB 10.5+ that causes failures in
+  Sequel's association tests.

data/doc/release_notes/5.59.0.txt

@@ -0,0 +1,73 @@
+= New Features
+
+* A require_valid_schema plugin has been added, for checking that
+  model classes have schema parsed as expected.  By default, model
+  classes are not required to have valid schema, because it is
+  allowed to have model classes based on arbitrary datasets (such
+  as those using joins or set-returning functions), and it is not
+  possible to determine the schema for arbitary datasets.
+
+  Sequel swallows non-connection errors when trying to parse schema
+  for a model's dataset, but if schema parsing fails when you would
+  expect it to succeed, it results in a model where typecasting does
+  not work as expected.
+
+  The require_valid_schema plugin will raise an error when setting
+  the dataset for a model if schema parsing fails and the dataset
+  uses a simple table where you would expect schema parsing to
+  succeed.  You can also provide an argument of :warn when loading
+  the plugin, to warn instead of raising an error.
+
+  This plugin may not work correctly in all cases for all adapters,
+  especially external adapters. Adapters are not required to support
+  schema parsing.  Even if supported, adapters may not support
+  parsing schema for qualified tables, or parsing schema for views.
+  You should consider this plugin as a possible safety net.  Users
+  are encouraged to try using it and report any unexpected breakage,
+  as that may help improve schema parsing in adapters that Sequel
+  ships.
+
+* is_json and is_not_json methods have been added to the pg_json_ops
+  extension, for the IS [NOT] JSON operator supported in PostgreSQL
+  15+.
+
+* Index creation methods on PostgreSQL 15+ now support a
+  :nulls_distinct option, for NULLS [NOT] DISTINCT.  This allows you
+  to create unique indexes where NULL values are not considered
+  distinct.
+
+* View creation methods on PostgreSQL 15+ now support a
+  :security_invoker option to create a view where access is
+  determined by the permissions of the role that is accessing the
+  view, instead of the role that created the view.
+
+= Other Improvements
+
+* The :allow_eager association option is now set to false by default
+  for associations explicitly marked as :instance_specific, if the
+  :eager_loader association is not given.
+  
+* The postgres adapter now supports the sequel-postgres-pr driver.
+  The sequel-postgres-pr driver is a slimmed down fork of the
+  postgres-pr driver designed specifically for use by Sequel.
+
+* Model code that explicitly does not swallow connection errors
+  will also now not swallow disconnect errors. This can fix issues
+  where model classes are being loaded at runtime, and the query to
+  get the columns/schema for the model uses a connection that has
+  been disconnected.
+
+* Model classes created from aliased expressions and literal
+  strings no longer use the simple_table optimization, as there
+  are cases where doing so is not safe.
+
+= Backwards Compatibility
+
+* The change to not swallow disconnect errors when not swallowing
+  connection errors can result in exceptions being raised which
+  weren't raised previously.  In most cases, this will alert you
+  to issues in your application that should be fixed, but it
+  potentially it can result in regressions if you were OK with
+  the errors being swallowed.  If this does result in regressions
+  in your application, please file an issue and we can probably
+  add a setting controlling this feature.

data/doc/release_notes/5.6.0.txt

@@ -0,0 +1,31 @@
+= Improvements
+
+* Running migrations using one of the included migrators on separate
+  Database objects in separate threads simultaneously is now
+  supported.  Previously, the migrators were not thread-safe.
+
+* On Ruby 2.5+, :db_type entries in the schema hashes are now deduped
+  for a slight memory savings when using many columns with the same
+  database type.
+
+* The schema_caching extension now freezes string values in the
+  resulting hashes, just as the default schema parsing code started
+  doing in 5.5.0.
+
+* The schema_caching extension now supports the :callable_default
+  schema values used by the pg_json, pg_array, and pg_hstore
+  extensions, by removing the entry before caching and resetting it
+  after restoring the cache.
+
+* Identifier mangling rules are now respected when renaming columns on
+  Microsoft SQL Server.
+
+= Backwards Compatibility
+
+* The migrator internals were modified in order to support
+  thread-safety.  The private Migrator#remove_migration_classes
+  method has been removed, and #load_migration_file now returns the
+  migration object/class instead of populating Migration.descendants.
+  Migration.descendants is now only used for temporary storage, and
+  will no longer contain all migration objects/classes used by the
+  migrator.

data/doc/release_notes/5.60.0.txt

@@ -0,0 +1,22 @@
+= New Features
+
+* The date_arithmetic extension now supports arbitrary expressions
+  as interval values on PostgreSQL 9.4+.  Previously, only integers
+  were supported for the interval values.
+
+= Other Improvements
+
+* Most Kernel#respond_to? calls have been converted to equivalent
+  defined? calls for better performance.  defined? is a keyword
+  and is about 50% faster for the same behavior.
+
+* The is_distinct_from extension now supports the IS DISTINCT FROM
+  syntax natively on SQLite 3.39+, instead of emulating it.
+
+* HAVING without GROUP BY is now supported on SQLite 3.39+.
+
+* Coverage testing has been significantly expanded.  Previously,
+  the core, model, plugin, and extension code had 100% line/branch
+  coverage.  100% line/branch coverage has been added for the
+  core extensions, bin/sequel, and the postgres adapter with the
+  pg driver.

data/doc/release_notes/5.61.0.txt

@@ -0,0 +1,43 @@
+= Improvements
+
+* When typecasting strings to other types, Sequel::Database will now
+  by default not typecast strings that are much longer than expected
+  for the underlying type. Depending on the underlying type, there
+  is a limit of either 100 or 1000 bytes on the input string.  This
+  avoids potential performance issues when trying to convert
+  arbitrary sized user input to specific types.
+
+* The respond_to? to defined? change made in 5.60.0 was reverted in
+  5.60.1 as it broke cases on Ruby < 3 where the object had an unused
+  refinement that added the method.
+
+* When typecasting strings to integer, strings such as -0xa are now
+  treated as negative hexidecimal strings, similar to how 0xa is
+  treated as a positive hexidecimal string.
+
+* Database#foreign_key_list now returns results for partitioned
+  tables on PostgreSQL 11+.
+
+* Timestamps before the date of calendar reform are now handled
+  correctly by the pg_extended_date_support extension when using
+  Ruby 3.2 preview 2+.
+
+= Backwards Compatibility
+
+* The change to not typecast strings that are too long can break
+  backwards compatibility for applications that expect typecasting
+  for input beyond Sequel's limits.  You can disable the string
+  bytesize checking by setting:
+
+    DB.check_string_typecast_bytesize = false
+
+  or by passing the check_string_typecast_bytesize: false option when
+  creating the Database instance.
+
+* Code to workaround a bug in JRuby 9.2.0.0 has been removed from the
+  pg_extended_date_support extension.  Users of the extension should
+  upgrade to a newer JRuby version.
+
+* The is_json and is_not_json methods have been removed from the
+  pg_json_ops extension, as the underlying support was removed in
+  PostgreSQL 15 beta 4.