Switch PostgreSQL Database#indexes :include_invalid option to :invalid

The :include_invalid support has been switched to invalid: :include.
This adds support for requesting only invalid indexes using
invalid: :only. I probably should have done something similar when
adding support for partial indexes. This doesn't change the
:include_partial option to :partial (that wouldn't be backwards
compatible), though I'm willing to add support for partial: :include
and partial: :only if anyone wants that ability.

This removes the :include_invalid spec instead of modifying it. The
spec only worked correctly if the user running the specs is the
database superuser. That may be true in CI, but it's not recommended
for standard testing during development. I'm not sure how to force
an invalid index in all supported PostgreSQL versions, and since
this updates the add_index :only option specs to test the indexes
:invalid option, I don't think the separate spec is needed.

Since it's simple, add a mock adpater spec for use of the add_index
:only option.

Author: jeremyevans

CHANGELOG

@@ -1,3 +1,9 @@
+=== master
+
+* Add support for Database#create_index :only option on PostgreSQL 11+ (KirIgor) (#2343)
+
+* Add support for Database#indexes :invalid option on PostgresSQL (KirIgor, jeremyevans) (#2343)
+
 === 5.98.0 (2025-11-01)
 
 * Make insert_returning_select use RETURNING when using table_select plugin (jeremyevans) (#2339)

doc/postgresql.rdoc

@@ -555,9 +555,11 @@ handle locking:
 
 == PostgreSQL-specific reflection Support
 
-The Database#indexes method supports the options :include_partial and :include_invalid.
-These options allow partial and invalid indexes to be included in the results, respectively.
-By default, Sequel excludes both partial and invalid indexes.
+The Database#indexes method supports the options :include_partial and :invalid.
+These options allows partial indexes to be included and invalid indexes to be
+included in the results (`invalid: :include`) or to only return invalid indexes
+(`invalid: :only`), respectively.  By default, Sequel excludes both partial and
+invalid indexes.
 
 == Extended Error Info (<tt>postgres/pg only</tt>)
 

lib/sequel/adapters/shared/postgres.rb

@@ -669,12 +669,25 @@ def immediate_constraints(opts=OPTS)
         _set_constraints(' IMMEDIATE', opts)
       end
 
-      # Use the pg_* system tables to determine indexes on a table
+      # Use the pg_* system tables to determine indexes on a table. Options:
+      #
+      # :include_partial :: Set to true to include partial indexes
+      # :invalid :: Set to true or :only to only return invalid indexes.
+      #             Set to :include to also return both valid and invalid indexes.
+      #             When not set or other value given, does not return invalid indexes.
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
         cond = {Sequel[:tab][:oid]=>regclass_oid(table, opts)}
         cond[:indpred] = nil unless opts[:include_partial]
-        cond[:indisvalid] = true unless opts[:include_invalid]
+
+        case opts[:invalid]
+        when true, :only
+          cond[:indisvalid] = false
+        when :include
+          # nothing
+        else
+          cond[:indisvalid] = true
+        end
 
         indexes = {}
         _indexes_ds.where_each(cond) do |r|

spec/adapters/postgres_spec.rb

@@ -1576,13 +1576,6 @@ def before_create
     @db.indexes(:test, :include_partial=>true)[:tnv_partial].must_equal(:columns=>[:name, :value], :unique=>false, :deferrable=>nil)
   end
 
-  it "should support parsing invalid indexes with :include_invalid option" do
-    @db.add_index :test, [:name, :value], :name=>:tnv_invalid
-    @db.run("UPDATE pg_index SET indisvalid = false WHERE indexrelid = 'tnv_invalid'::regclass;")
-    @db.indexes(:test)[:tnv_invalid].must_be_nil
-    @db.indexes(:test, :include_invalid=>true)[:tnv_invalid].must_equal(:columns=>[:name, :value], :unique=>false, :deferrable=>nil)
-  end
-
   it "should support creating indexes concurrently" do
     @db.add_index :test, [:name, :value], :concurrently=>true, :name=>'tnv0'
   end
@@ -1642,12 +1635,20 @@ def before_create
   end
 
   it "should support creating indexes with ONLY option" do
-    @db.create_table(:atest, partition_by: :id, :partition_type=>:range){Integer :id}
+    @db.create_table(:atest, partition_by: :id, :partition_type=>:range){Integer :id; String :name}
     @db.create_table(:btest, partition_of: :atest){from 1; to 3}
-    @db.add_index :atest, :id, :only=>true
-
-    @db.indexes(:atest, :include_invalid=>true).size.must_equal 1
-    @db.indexes(:btest, :include_invalid=>true).must_be_empty
+    @db.add_index :atest, :id, :only=>true, :name=>:atest_id_only_idx
+    @db.add_index :atest, :name, :name=>:atest_name_only_idx
+
+    @db.indexes(:atest).keys.must_equal [:atest_name_only_idx]
+    @db.indexes(:atest, :invalid=>true).keys.must_equal [:atest_id_only_idx]
+    @db.indexes(:atest, :invalid=>:only).keys.must_equal [:atest_id_only_idx]
+    @db.indexes(:atest, :invalid=>:include).keys.sort.must_equal [:atest_id_only_idx, :atest_name_only_idx]
+
+    @db.indexes(:btest).keys.must_equal [:btest_name_idx]
+    @db.indexes(:btest, :invalid=>true).keys.must_equal []
+    @db.indexes(:btest, :invalid=>:only).keys.must_equal []
+    @db.indexes(:btest, :invalid=>:include).keys.sort.must_equal [:btest_name_idx]
   end if DB.server_version >= 110000
 
   it "#lock should lock table if inside a transaction" do

spec/core/mock_adapter_spec.rb

@@ -627,6 +627,11 @@ def a.method_missing(m, *x) push(*x) end
     @db.sqls.must_equal ['CREATE INDEX "posts_user_id_index" ON "posts" USING btree ("user_id" int4_ops)']
   end
 
+  it "should support add_index :only option" do
+    @db.alter_table(:posts){add_index(:user_id, :only=> true)}
+    @db.sqls.must_equal ['CREATE INDEX "posts_user_id_index" ON ONLY "posts" ("user_id")']
+  end
+
   it 'should quote NaN' do
     nan = 0.0/0.0
     @db[:test5].insert_sql(:value => nan).must_equal %q{INSERT INTO "test5" ("value") VALUES ('NaN')}