pg_trgm word_similarity query does not use index for input strings longer than 8 characters

Hello,

recently I wrote a query that provides suggestions from a Postgres table.
It should be able to work despite smaller typos and thus I chose to use
the pg_trgm extension (https://www.postgresql.org/docs/current/pgtrgm.html)
When measuring the performance, I observed great differences in the
query time, depending on the input string.
Analysis showed that Postgres sometimes used the created indexes and
sometimes it didn't, even though it would provide a considerable speedup.

In the included test case the degradation occurs for all input strings
of length 8 or longer, for shorter strings the index is used.

My questions:
Why doesn't the query planner choose to use the index?
Can I make Postgres use the index, and if so, how?
I understand that trying to outsmart the planner is generally a bad
idea. Maybe the query can be rewritten or there are some parameters that
could be tweaked.

## Setup Information

Hardware: Intel i5-8250U, 8GB RAM, encrypted SSD, no RAID
$ uname -a
Linux 5.11.0-40-generic #44~20.04.2-Ubuntu SMP Tue Oct 26 18:07:44 UTC
2021 x86_64 x86_64 x86_64 GNU/Linux

Software:
OS: Ubuntu 20.04
Postgres: PostgreSQL 14.1 (Debian 14.1-1.pgdg110+1) on
x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110,
64-bit
The Postgres docker image was used.
Docker: Docker version 20.10.5, build 55c4c88
Image used: postgres:14.1

Configuration:
The config file was not changed.
name | current_setting | source
----------------------------+--------------------+----------------------
application_name | psql | client
client_encoding | UTF8 | client
DateStyle | ISO, MDY | configuration file
default_text_search_config | pg_catalog.english | configuration file
dynamic_shared_memory_type | posix | configuration file
enable_seqscan | off | session
lc_messages | en_US.utf8 | configuration file
lc_monetary | en_US.utf8 | configuration file
lc_numeric | en_US.utf8 | configuration file
lc_time | en_US.utf8 | configuration file
listen_addresses | * | configuration file
log_timezone | Etc/UTC | configuration file
max_connections | 100 | configuration file
max_stack_depth | 2MB | environment variable
max_wal_size | 1GB | configuration file
min_wal_size | 80MB | configuration file
shared_buffers | 128MB | configuration file
TimeZone | Etc/UTC | configuration file

## Test Case
The test case creates a simple table and fills it with 10000 identical
entries.
The query is executed twice with an 8 character string, once with
sequential scans enabled, and once with sequential scans disabled.
The first query does not use the index, even if the second query shows
that it would be much faster.

docker run --name postgres -e POSTGRES_PASSWORD=postgres -d postgres:14.1
docker exec -it postgres bash
psql -U postgres

CREATE EXTENSION pg_trgm;

CREATE TABLE song (
artist varchar(20),
title varchar(20)
);

INSERT INTO song (artist, title)
SELECT 'artist','title'
FROM generate_series(1,10000);

CREATE INDEX artist_trgm ON song USING GIN (artist gin_trgm_ops);
CREATE INDEX title_trgm ON song USING GIN (title gin_trgm_ops);

-- Tips from https://wiki.postgresql.org/wiki/Slow_Query_Questions
ANALYZE;
VACUUM;
REINDEX TABLE song;

\set query '12345678'

-- This query is slow
EXPLAIN ANALYZE
SELECT song.artist, song.title
FROM song
WHERE (song.artist %> :'query' OR song.title %> :'query')
;

set enable_seqscan=off;

-- This query is fast
EXPLAIN ANALYZE
SELECT song.artist, song.title
FROM song
WHERE (song.artist %> :'query' OR song.title %> :'query')
;

## Additional Test Case Info

Schemata:
Table "public.song"
Column | Type | Collation | Nullable | Default |
Storage | Compression | Stats target | Description
--------+-----------------------+-----------+----------+---------+----------+-------------+--------------+-------------
artist | character varying(20) | | | |
extended | | |
title | character varying(20) | | | |
extended | | |
Indexes:
"artist_trgm" gin (artist gin_trgm_ops)
"title_trgm" gin (title gin_trgm_ops)
Access method: heap
Index "public.artist_trgm"
Column | Type | Key? | Definition | Storage | Stats target
--------+---------+------+------------+---------+--------------
artist | integer | yes | artist | plain |
gin, for table "public.song"
Index "public.title_trgm"
Column | Type | Key? | Definition | Storage | Stats target
--------+---------+------+------------+---------+--------------
title | integer | yes | title | plain |
gin, for table "public.song"

Table Metadata:
postgres=# SELECT relname, relpages, reltuples, relallvisible, relkind,
relnatts, relhassubclass, reloptions, pg_table_size(oid) FROM pg_class
WHERE relname='song';
relname | relpages | reltuples | relallvisible | relkind | relnatts |
relhassubclass | reloptions | pg_table_size
---------+----------+-----------+---------------+---------+----------+----------------+------------+---------------
song | 55 | 10000 | 55 | r | 2 |
f | | 483328

EXPLAIN ANALYZE of the "slow" query
QUERY PLAN
---------------------------------------------------------------------------------------------------
Seq Scan on song (cost=0.00..205.00 rows=1 width=13) (actual
time=68.896..68.897 rows=0 loops=1)
Filter: (((artist)::text %> '12345678'::text) OR ((title)::text %>
'12345678'::text))
Rows Removed by Filter: 10000
Planning Time: 0.304 ms
Execution Time: 68.928 ms

EXPLAIN ANALYZE of the "fast" query
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------
Bitmap Heap Scan on song (cost=288.00..292.02 rows=1 width=13)
(actual time=0.023..0.024 rows=0 loops=1)
Recheck Cond: (((artist)::text %> '12345678'::text) OR
((title)::text %> '12345678'::text))
-> BitmapOr (cost=288.00..288.00 rows=1 width=0) (actual
time=0.022..0.023 rows=0 loops=1)
-> Bitmap Index Scan on artist_trgm (cost=0.00..144.00
rows=1 width=0) (actual time=0.013..0.014 rows=0 loops=1)
Index Cond: ((artist)::text %> '12345678'::text)
-> Bitmap Index Scan on title_trgm (cost=0.00..144.00 rows=1
width=0) (actual time=0.008..0.008 rows=0 loops=1)
Index Cond: ((title)::text %> '12345678'::text)
Planning Time: 0.224 ms
Execution Time: 0.052 ms

The behaviour is identical when using similarity instead of word_similarity.
GIN indexes were chosen because the table is queried far more often than
it is updated.
I tried increasing shared_buffers, effective_cache_size or work_mem to
no avail.

Any help would be greatly appreciated.

Regards
Jonathan