sequel 5.73.0 → 5.75.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf3b8749cd91ac285e66359ae16adf9605c13e673a0cf3f7251527573d71fed6
-  data.tar.gz: 817f6980be08b29368eb0f08631d64ae48a4281aa1b2974b589441fea50e2dac
+  metadata.gz: 3047129164c9cdffee31414419904329e410db71e7e4243c0549614498a2b0d4
+  data.tar.gz: 9cc84ed8e9dba53aac7175be04699089932566e4015aed7a465c43552808c8b4
 SHA512:
-  metadata.gz: 6da7c5e7a7c74c4767c55d126adc3743875a5dd0822ee780b22b1ca3c3791cc10d08cf74c984776dbd9fbbcf61d9246bcef4c81e64204e5d72aa59545ef9a2d9
-  data.tar.gz: 7ac12f6689d846345fed77e23665679ae4886d60e4d25d4e201a3cfdac4f231882af0aaf3e615bd9981d09c2e9537c1e287fad614f81760f2d897b87402b38b1
+  metadata.gz: 15ed5c13e4793191546cd452aa5865e65fd7b3bb0458ffdb674d526398b7c9446e2da0f43a339daa3f1dc256eb551f0b773ac9ffc192b4d19f389d0c7e296d98
+  data.tar.gz: 1f25851b50857fbbf8378216794f26d0d8e9baa247f008feac466a218ae6b0777249252b6d05756e075096c5312b9d3b1334b7c4bc1884251e7b892cc17ae7c6

data/CHANGELOG

@@ -1,3 +1,25 @@
+=== 5.75.0 (2023-12-01)
+
+* Make any_not_empty? extension support passing pattern argument to any? (jeremyevans) (#2100)
+
+* Respect :skip_transaction option in PostgreSQL Dataset#paged_each (jeremyevans) (#2097)
+
+* Add TimestampMigrator.run_single to run a single migration file up or down (opya, jeremyevans) (#2093)
+
+* Support INSERT RETURNING on MariaDB 10.5+, and use it when saving new model objects (jeremyevans)
+
+* Add Database#{defer,immediate}_constraints on PostgreSQL for changing handling of deferrable constraints in a transaction (jeremyevans)
+
+=== 5.74.0 (2023-11-01)
+
+* Make generated columns show up in Database#schema when using SQLite 3.37+ (jeremyevans) (#2087)
+
+* Add revert method for Sequel.migration blocks, to revert changes inside the block on up, and apply the changes on down (jeremyevans)
+
+* Re-add is_json and is_not_json methods to the pg_json_ops extension, as the support was re-added in PostgreSQL 16 (jeremyevans)
+
+* Avoid infinite loop when handling exceptions with a cause loop in jdbc adapter (jeremyevans)
+
 === 5.73.0 (2023-10-01)
 
 * Handle disconnect errors in ibmdb and jdbc/db2 adapters (jeremyevans) (#2083)

data/doc/migration.rdoc

@@ -90,6 +90,20 @@ the following methods:
 
 If you use any other methods, you should create your own +down+ block.
 
+To revert a migration created with +change+, you can copy the migration to a new file, and
+replace +change+ with +revert+. For example, if you no longer need the artists table, you
+can use the following migration.  This will drop the artists table when migrating up, and
+recreate it when migrating down:
+
+  Sequel.migration do
+    revert do
+      create_table(:artists) do
+        primary_key :id
+        String :name, null: false
+      end
+    end
+  end
+
 In normal usage, when Sequel's migrator runs, it runs the +up+ blocks for all
 migrations that have not yet been applied.  However, you can use the <tt>-M</tt>
 switch to specify the version to which to migrate, and if it is lower than the

data/doc/release_notes/5.74.0.txt

@@ -0,0 +1,45 @@
+= New Features
+
+* Sequel.migration blocks now support a revert method, which reverts
+  the changes in the block on up, and applies them on down.  So if
+  you have a migration such as:
+
+    Sequel.migration do
+      change do
+        create_table :table do
+          # ...
+        end
+      end
+    end
+
+  and you later want to add a migration that drops the table, you
+  can use:
+
+    Sequel.migration do
+      revert do
+        create_table :table do
+          # ...
+        end
+      end
+    end
+
+  This will drop the table when migrating up, and create a table 
+  with the given schema when migrating down.
+
+* 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
+  16+.  These were previously added in Sequel 5.59.0, and removed
+  in Sequel 5.61.0 as support was removed in PostgreSQL 15 beta 4.
+  PostgreSQL 16 shipped with support for them, so support has been
+  recommitted to Sequel.
+
+= Other Improvements
+
+* SQLite generated columns now show up in Database#schema when using
+  SQLite 3.37+.
+
+* Sequel now attempts to avoid an infinite loop in pathlogical cases
+  in the jdbc adapter, where the exception cause chain has a loop.
+  Additionally, if an exception is already recognized as a disconnect,
+  or an exception already responds to a getSQLState method, Sequel no
+  longer looks at the causes of the exception.

data/doc/release_notes/5.75.0.txt

@@ -0,0 +1,35 @@
+= New Features
+
+* Database#{defer,immediate}_constraints methods have been added on
+  PostgreSQL for changing handling of deferrable constraints inside
+  a transaction. defer_constraints sets deferrable constraints to
+  be deferred (not checked until transaction commit), and
+  immediate_constraints sets deferrable constraints to be checked
+  as part of the related query, and any already deferred constraint
+  checks to be applied immediately. You can pass the :constraints
+  option to only apply the changes to specific constraints.
+
+* TimestampMigrator.run_single has been added, to migrate a single
+  migration up or down.
+
+= Other Improvements
+
+* INSERT RETURNING is now supported on MariaDB 10.5+, and used
+  automatically when saving new model objects. Note that this
+  is not supported when using the jdbc adapter, because the
+  jdbc-mysql driver doesn't support it.  A jdbc/mariadb adapter
+  could be added, as it's likely recent versions of the
+  jdbc-mariadb driver would support it, but the jdbc-mariadb gem 
+  hasn't been updated in over 4 years.  Talk to the jdbc-mariadb
+  gem maintainers if you want to use this feature with the jdbc
+  adapter.
+
+* The Dataset#paged_each optimization in the postgres adapter
+  now respects the :skip_transaction option, making it the
+  same as the :hold option.  Note that this has effects beyond
+  just skipping the transaction, but non-HOLD cursors are only
+  supported inside transactions.
+
+* The any_not_empty? extension's Dataset#any? method now supports
+  an argument, passing it to Enumerable#any? (which has supported
+  an argument since Ruby 2.5).

data/lib/sequel/adapters/jdbc/db2.rb

@@ -36,10 +36,6 @@ module Sequel
 
         private
 
-        def database_exception_sqlstate(exception, opts)
-          exception.sql_state if exception.respond_to?(:sql_state)
-        end
-
         def set_ps_arg(cps, arg, i)
           case arg
           when Sequel::SQL::Blob

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

@@ -36,6 +36,10 @@ module Sequel
 
         private
 
+        def database_exception_use_sqlstates?
+          false
+        end
+
         # Use @@IDENTITY to get the last inserted id
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|

data/lib/sequel/adapters/jdbc/sqlserver.rb

@@ -79,6 +79,10 @@ module Sequel
           super.with_extend(MetadataDatasetMethods)
         end
 
+        def database_exception_use_sqlstates?
+          false
+        end
+
         def disconnect_error?(exception, opts)
           super || (exception.message =~ /connection is closed/)
         end

data/lib/sequel/adapters/jdbc.rb

@@ -396,11 +396,16 @@ module Sequel
 
       def database_exception_sqlstate(exception, opts)
         if database_exception_use_sqlstates?
-          while exception.respond_to?(:cause)
-            exception = exception.cause
-            return exception.getSQLState if exception.respond_to?(:getSQLState)
-          end
+          _database_exception_sqlstate(exception, opts)
         end
+      end
+
+      def _database_exception_sqlstate(exception, opts)
+        16.times do
+          return exception.getSQLState if exception.respond_to?(:getSQLState)
+          break unless exception.respond_to?(:cause) && (exception = exception.cause)
+        end
+
         nil
       end
 
@@ -415,8 +420,7 @@ module Sequel
 
       # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
       def disconnect_error?(exception, opts)
-        cause = exception.respond_to?(:cause) ? exception.cause : exception
-        super || (cause.respond_to?(:getSQLState) && cause.getSQLState =~ /^08/)
+        super || (_database_exception_sqlstate(exception, opts) =~ /^08/)
       end
 
       # Execute the prepared statement.  If the provided name is a

data/lib/sequel/adapters/postgres.rb

@@ -672,6 +672,7 @@ module Sequel
       #          cursor usage.
       # :rows_per_fetch :: The number of rows per fetch (default 1000).  Higher
       #                    numbers result in fewer queries but greater memory use.
+      # :skip_transaction :: Same as :hold, but :hold takes priority.
       #
       # Usage:
       #
@@ -764,13 +765,13 @@ module Sequel
 
       # Use a cursor to fetch groups of records at a time, yielding them to the block.
       def cursor_fetch_rows(sql)
-        server_opts = {:server=>@opts[:server] || :read_only}
         cursor = @opts[:cursor]
-        hold = cursor[:hold]
+        hold = cursor.fetch(:hold){cursor[:skip_transaction]}
+        server_opts = {:server=>@opts[:server] || :read_only, :skip_transaction=>hold}
         cursor_name = quote_identifier(cursor[:cursor_name] || 'sequel_cursor')
         rows_per_fetch = cursor[:rows_per_fetch].to_i
 
-        db.public_send(*(hold ? [:synchronize, server_opts[:server]] : [:transaction, server_opts])) do 
+        db.transaction(server_opts) do 
           begin
             execute_ddl("DECLARE #{cursor_name} NO SCROLL CURSOR WITH#{'OUT' unless hold} HOLD FOR #{sql}", server_opts)
             rows_per_fetch = 1000 if rows_per_fetch <= 0

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

@@ -646,7 +646,7 @@ module Sequel
       MATCH_AGAINST_BOOLEAN = ["MATCH ".freeze, " AGAINST (".freeze, " IN BOOLEAN MODE)".freeze].freeze
 
       Dataset.def_sql_method(self, :delete, %w'with delete from where order limit')
-      Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
+      Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update returning')
       Dataset.def_sql_method(self, :select, %w'with select distinct calc_found_rows columns from join where group having window compounds order limit lock')
       Dataset.def_sql_method(self, :update, %w'with update ignore table set where order limit')
 
@@ -774,6 +774,21 @@ module Sequel
         clone(:insert_ignore=>true)
       end
 
+      # Support insert select for associations, so that the model code can use
+      # returning instead of a separate query.
+      def insert_select(*values)
+        return unless supports_insert_select?
+        # Handle case where query does not return a row
+        server?(:default).with_sql_first(insert_select_sql(*values)) || false
+      end
+
+      # The SQL to use for an insert_select, adds a RETURNING clause to the insert
+      # unless the RETURNING clause is already present.
+      def insert_select_sql(*values)
+        ds = opts[:returning] ? self : returning
+        ds.insert_sql(*values)
+      end
+
       # Sets up the insert methods to use ON DUPLICATE KEY UPDATE
       # If you pass no arguments, ALL fields will be
       # updated with the new values.  If you pass the fields you
@@ -871,6 +886,11 @@ module Sequel
         true
       end
 
+      # MariaDB 10.5.0 supports INSERT RETURNING.
+      def supports_returning?(type)
+        (type == :insert && db.mariadb? && db.adapter_scheme != :jdbc) ? (db.server_version >= 100500) : false
+      end
+
       # MySQL 8+ supports SKIP LOCKED.
       def supports_skip_locked?
         !db.mariadb? && db.server_version >= 80000

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

@@ -498,6 +498,25 @@ module Sequel
         :postgres
       end
 
+      # For constraints that are deferrable, defer constraints until 
+      # transaction commit. Options:
+      #
+      # :constraints :: An identifier of the constraint, or an array of
+      #                 identifiers for constraints, to apply this
+      #                 change to specific constraints.
+      # :server :: The server/shard on which to run the query.
+      #
+      # Examples:
+      #
+      #   DB.defer_constraints
+      #   # SET CONSTRAINTS ALL DEFERRED
+      #
+      #   DB.defer_constraints(constraints: [:c1, Sequel[:sc][:c2]])
+      #   # SET CONSTRAINTS "c1", "sc"."s2" DEFERRED
+      def defer_constraints(opts=OPTS)
+        _set_constraints(' DEFERRED', opts)
+      end
+
       # Use PostgreSQL's DO syntax to execute an anonymous code block.  The code should
       # be the literal code string to use in the underlying procedural language.  Options:
       #
@@ -611,6 +630,24 @@ module Sequel
         super
       end
 
+      # Immediately apply deferrable constraints.
+      #
+      # :constraints :: An identifier of the constraint, or an array of
+      #                 identifiers for constraints, to apply this
+      #                 change to specific constraints.
+      # :server :: The server/shard on which to run the query.
+      #
+      # Examples:
+      #
+      #   DB.immediate_constraints
+      #   # SET CONSTRAINTS ALL IMMEDIATE
+      #
+      #   DB.immediate_constraints(constraints: [:c1, Sequel[:sc][:c2]])
+      #   # SET CONSTRAINTS "c1", "sc"."s2" IMMEDIATE
+      def immediate_constraints(opts=OPTS)
+        _set_constraints(' IMMEDIATE', opts)
+      end
+
       # Use the pg_* system tables to determine indexes on a table
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
@@ -1038,6 +1075,23 @@ module Sequel
         end
       end
 
+      # Internals of defer_constraints/immediate_constraints
+      def _set_constraints(type, opts)
+        execute_ddl(_set_constraints_sql(type, opts), opts)
+      end
+
+      # SQL to use for SET CONSTRAINTS
+      def _set_constraints_sql(type, opts)
+        sql = String.new
+        sql << "SET CONSTRAINTS "
+        if constraints = opts[:constraints]
+          dataset.send(:source_list_append, sql, Array(constraints))
+        else
+          sql << "ALL"
+        end
+        sql << type
+      end
+
       def alter_table_add_column_sql(table, op)
         "ADD COLUMN#{' IF NOT EXISTS' if op[:if_not_exists]} #{column_definition_sql(op)}"
       end

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

@@ -504,7 +504,6 @@ module Sequel
             # table_xinfo PRAGMA used, remove hidden columns
             # that are not generated columns
             if row[:generated] = (row.delete(:hidden) != 0)
-              next unless row[:type].end_with?(' GENERATED ALWAYS')
               row[:type] = row[:type].sub(' GENERATED ALWAYS', '')
             end
           end

data/lib/sequel/extensions/any_not_empty.rb

@@ -32,8 +32,8 @@
 module Sequel
   module AnyNotEmpty
     # If a block is not given, return whether the dataset is not empty.
-    def any?
-      if defined?(yield)
+    def any?(*a)
+      if !a.empty? || defined?(yield)
         super
       else
         !empty?

data/lib/sequel/extensions/migration.rb

@@ -159,6 +159,19 @@ module Sequel
       migration.up = block
       migration.down = MigrationReverser.new.reverse(&block)
     end
+
+    # Creates a revert migration.  This is the same as creating
+    # the same block with +down+, but it also calls the block and attempts
+    # to create a +up+ block that will reverse the changes made by
+    # the block.  This is designed to revert the changes in the
+    # provided block.
+    #
+    # There are no guarantees that this will work perfectly
+    # in all cases, but it works for some simple cases.
+    def revert(&block)
+      migration.down = block
+      migration.up = MigrationReverser.new.reverse(&block)
+    end
   end
 
   # Handles the reversing of reversible migrations.  Basically records
@@ -680,6 +693,13 @@ module Sequel
       @migration_tuples = get_migration_tuples
     end
 
+    # Apply the migration in the given file path.  See Migrator.run for the
+    # available options.  Additionally, this method supports the :direction
+    # option for whether to run the migration up (default) or down.
+    def self.run_single(db, path, opts=OPTS)
+      new(db, File.dirname(path), opts).run_single(path, opts[:direction] || :up)
+    end
+
     # The timestamp migrator is current if there are no migrations to apply
     # in either direction.
     def is_current?
@@ -689,20 +709,39 @@ module Sequel
     # Apply all migration tuples on the database
     def run
       migration_tuples.each do |m, f, direction|
-        t = Time.now
-        db.log_info("Begin applying migration #{f}, direction: #{direction}")
-        checked_transaction(m) do
-          m.apply(db, direction)
-          fi = f.downcase
-          direction == :up ? ds.insert(column=>fi) : ds.where(column=>fi).delete
-        end
-        db.log_info("Finished applying migration #{f}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
+        apply_migration(m, f, direction)
       end
       nil
     end
 
+    # Apply single migration tuple at the given path with the given direction
+    # on the database.
+    def run_single(path, direction)
+      migration = load_migration_file(path)
+      file_name = File.basename(path)
+      already_applied = applied_migrations.include?(file_name.downcase)
+
+      return if direction == :up ? already_applied : !already_applied
+
+      apply_migration(migration, file_name, direction)
+      nil
+    end
+
     private
 
+    # Apply a single migration with the given filename in the given direction.
+    def apply_migration(migration, file_name, direction)
+      fi = file_name.downcase
+      t = Time.now
+
+      db.log_info("Begin applying migration #{file_name}, direction: #{direction}")
+      checked_transaction(migration) do
+        migration.apply(db, direction)
+        direction == :up ? ds.insert(column=>fi) : ds.where(column=>fi).delete
+      end
+      db.log_info("Finished applying migration #{file_name}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
+    end
+
     # Convert the schema_info table to the new schema_migrations table format,
     # using the version of the schema_info table and the current migration files.
     def convert_from_schema_info

data/lib/sequel/extensions/pg_json_ops.rb

@@ -123,6 +123,15 @@
 #   c = Sequel.pg_jsonb_op(:c)
 #   DB[:t].update(c['key1'] => 1.to_json, c['key2'] => "a".to_json)
 #
+# On PostgreSQL 16+, the <tt>IS [NOT] JSON</tt> operator is supported:
+#
+#   j.is_json                              # j IS JSON
+#   j.is_json(type: :object)               # j IS JSON OBJECT
+#   j.is_json(type: :object, unique: true) # j IS JSON OBJECT WITH UNIQUE
+#   j.is_not_json                          # j IS NOT JSON
+#   j.is_not_json(type: :array)                # j IS NOT JSON ARRAY
+#   j.is_not_json(unique: true)                # j IS NOT JSON WITH UNIQUE
+#
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
 # JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
@@ -151,6 +160,18 @@ module Sequel
       GET_PATH = ["(".freeze, " #> ".freeze, ")".freeze].freeze
       GET_PATH_TEXT = ["(".freeze, " #>> ".freeze, ")".freeze].freeze
 
+      IS_JSON = ["(".freeze, " IS JSON".freeze, "".freeze, ")".freeze].freeze
+      IS_NOT_JSON = ["(".freeze, " IS NOT JSON".freeze, "".freeze, ")".freeze].freeze
+      EMPTY_STRING = Sequel::LiteralString.new('').freeze
+      WITH_UNIQUE = Sequel::LiteralString.new(' WITH UNIQUE').freeze
+      IS_JSON_MAP = {
+        nil => EMPTY_STRING,
+        :value => Sequel::LiteralString.new(' VALUE').freeze,
+        :scalar => Sequel::LiteralString.new(' SCALAR').freeze,
+        :object => Sequel::LiteralString.new(' OBJECT').freeze,
+        :array => Sequel::LiteralString.new(' ARRAY').freeze
+      }.freeze
+
       # Get JSON array element or object field as json.  If an array is given,
       # gets the object at the specified path.
       #
@@ -233,6 +254,30 @@ module Sequel
         end
       end
 
+      # Return whether the json object can be parsed as JSON.
+      #
+      # Options:
+      # :type :: Check whether the json object can be parsed as a specific type
+      #          of JSON (:value, :scalar, :object, :array).
+      # :unique :: Check JSON objects for unique keys.
+      #
+      #   json_op.is_json                 # json IS JSON
+      #   json_op.is_json(type: :object)  # json IS JSON OBJECT
+      #   json_op.is_json(unique: true)   # json IS JSON WITH UNIQUE
+      def is_json(opts=OPTS)
+        _is_json(IS_JSON, opts)
+      end
+
+      # Return whether the json object cannot be parsed as JSON. The opposite
+      # of #is_json. See #is_json for options.
+      #
+      #   json_op.is_not_json                 # json IS NOT JSON
+      #   json_op.is_not_json(type: :object)  # json IS NOT JSON OBJECT
+      #   json_op.is_not_json(unique: true)   # json IS NOT JSON WITH UNIQUE
+      def is_not_json(opts=OPTS)
+        _is_json(IS_NOT_JSON, opts)
+      end
+
       # Returns a set of keys AS text in the json object.
       #
       #   json_op.keys # json_object_keys(json)
@@ -286,6 +331,13 @@ module Sequel
 
       private
 
+      # Internals of IS [NOT] JSON support
+      def _is_json(lit_array, opts)
+        raise Error, "invalid is_json :type option: #{opts[:type].inspect}" unless type = IS_JSON_MAP[opts[:type]]
+        unique = opts[:unique] ? WITH_UNIQUE : EMPTY_STRING
+        Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(lit_array, [self, type, unique]))
+      end
+
       # Return a placeholder literal with the given str and args, wrapped
       # in an JSONOp or JSONBOp, used by operators that return json or jsonb.
       def json_op(str, args)

data/lib/sequel/plugins/column_encryption.rb

@@ -325,7 +325,7 @@ module Sequel
     #   DB.alter_table(:ce_test) do
     #     c = Sequel[:encrypted_column_name]
     #     add_constraint(:enc_base64) do
-    #       octet_length(decode(regexp_replace(regexp_replace(c, '_', '/', 'g'), '-', '+', 'g'), 'base64')) >= 65}
+    #       octet_length(decode(regexp_replace(regexp_replace(c, '_', '/', 'g'), '-', '+', 'g'), 'base64')) >= 65
     #     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 = 73
+  MINOR = 75
 
   # 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.73.0
+  version: 5.75.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-01 00:00:00.000000000 Z
+date: 2023-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -220,6 +220,8 @@ extra_rdoc_files:
 - doc/release_notes/5.71.0.txt
 - doc/release_notes/5.72.0.txt
 - doc/release_notes/5.73.0.txt
+- doc/release_notes/5.74.0.txt
+- doc/release_notes/5.75.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 files:
@@ -321,6 +323,8 @@ files:
 - doc/release_notes/5.71.0.txt
 - doc/release_notes/5.72.0.txt
 - doc/release_notes/5.73.0.txt
+- doc/release_notes/5.74.0.txt
+- doc/release_notes/5.75.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 - doc/schema_modification.rdoc