Tous les produits
Search
Centre de documentation

ApsaraDB RDS:Requête floue (pg_bigm)

Dernière mise à jour :Aug 08, 2026

pg_bigm est une extension pour Alibaba Cloud RDS for PostgreSQL qui permet la recherche en texte intégral via un index inversé généralisé (GIN) basé sur les 2-grammes. Elle s'avère efficace pour les langues non alphabétiques, comme le japonais et le chinois, ainsi que pour les mots-clés courts de 1 à 2 caractères.

Quand utiliser pg_bigm

pg_bigm et pg_trgm sont des extensions de recherche en texte intégral pour RDS for PostgreSQL. Le tableau suivant vous aide à choisir l'extension appropriée.

Fonctionnalité pg_trgm pg_bigm
Méthode de correspondance de phrase 3-gramme 2-gramme
Types d'index pris en charge GIN et GiST GIN
Opérateurs de recherche en texte intégral pris en charge LIKE, ILIKE, ~ et ~* LIKE
Recherche en texte intégral pour les langues non alphabétiques Non prise en charge Prise en charge
Recherche en texte intégral pour les mots-clés de 1 à 2 caractères Lente Rapide
Recherche par similarité Prise en charge Prise en charge
Taille maximale d'une colonne indexable 238 609 291 octets (~228 Mo) 107 374 180 octets (~102 Mo)

Choisissez pg_bigm si vos données contiennent du contenu non alphabétique ou si vous recherchez fréquemment des mots-clés très courts. Privilégiez pg_trgm pour une recherche insensible à la casse (ILIKE) ou pour utiliser des opérateurs d'expression régulière (~, ~*).

Prérequis

Avant de commencer, vérifiez que vous disposez des éléments suivants :

  • Une instance RDS for PostgreSQL répondant aux exigences de version suivantes :

    Important

    Vous ne pouvez pas créer pg_bigm sur des instances exécutant une version mineure du moteur antérieure à 20230830. Si votre instance utilise une version plus ancienne et que cette extension est déjà installée, elle continue de fonctionner normalement. Pour installer ou réinstaller l'extension, mettez à jour la version mineure du moteur vers la dernière version disponible. Pour plus de détails, consultez la section Restrictions liées à la création d'extensions.

    Version majeure Version mineure du moteur
    PostgreSQL 17 20250830 ou ultérieure
    PostgreSQL 16 Aucune restriction
    PostgreSQL 10–15 20230830 ou ultérieure
  • Ajoutez pg_bigm à la Value du paramètre shared_preload_libraries. Par exemple : 'pg_stat_statements,auto_explain,pg_bigm'. Pour obtenir des instructions, consultez la rubrique Définir les paramètres d'instance.

Limitations

  • La taille de la colonne d'index GIN ne doit pas dépasser 107 374 180 octets (~102 Mo).

  • Si la base de données contient du contenu non ASCII, définissez son encodage de caractères sur UTF8. Pour vérifier l'encodage actuel, exécutez la commande suivante :

    SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname = current_database();

Opérations de base

Créer l'extension

postgres=> CREATE EXTENSION pg_bigm;
CREATE EXTENSION

Créer un index GIN

Créez une table, insérez des données et générez un index GIN en utilisant gin_bigm_ops :

postgres=> CREATE TABLE pg_tools (tool text, description text);
CREATE TABLE
postgres=> INSERT INTO pg_tools VALUES ('pg_hint_plan', 'Tool that allows a user to specify an optimizer HINT to PostgreSQL');
INSERT 0 1
postgres=> INSERT INTO pg_tools VALUES ('pg_dbms_stats', 'Tool that allows a user to stabilize planner statistics in PostgreSQL');
INSERT 0 1
postgres=> INSERT INTO pg_tools VALUES ('pg_bigm', 'Tool that provides 2-gram full text search capability in PostgreSQL');
INSERT 0 1
postgres=> INSERT INTO pg_tools VALUES ('pg_trgm', 'Tool that provides 3-gram full text search capability in PostgreSQL');
INSERT 0 1

-- Single-column GIN index
postgres=> CREATE INDEX pg_tools_idx ON pg_tools USING gin (description gin_bigm_ops);
CREATE INDEX

-- Multi-column GIN index with FASTUPDATE disabled
postgres=> CREATE INDEX pg_tools_multi_idx ON pg_tools USING gin (tool gin_bigm_ops, description gin_bigm_ops) WITH (FASTUPDATE = off);
CREATE INDEX

Rechercher en texte intégral

Utilisez l'opérateur LIKE avec le modèle %keyword% :

postgres=> SELECT * FROM pg_tools WHERE description LIKE '%search%';
  tool   |                             description
---------+---------------------------------------------------------------------
 pg_bigm | Tool that provides 2-gram full text search capability in PostgreSQL
 pg_trgm | Tool that provides 3-gram full text search capability in PostgreSQL
(2 rows)

Rechercher par similarité

Utilisez l'opérateur =% avec pg_bigm.similarity_limit pour contrôler le seuil de correspondance :

postgres=> SET pg_bigm.similarity_limit TO 0.2;
SET
postgres=> SELECT tool FROM pg_tools WHERE tool =% 'bigm';
  tool
---------
 pg_bigm
 pg_trgm
(2 rows)

Désinstaller l'extension

postgres=> DROP EXTENSION pg_bigm;
DROP EXTENSION

Fonctions de l'extension

likequery

Dans pg_bigm, la recherche en texte intégral repose sur la correspondance de motif LIKE. Vous devez entourer le mot-clé recherché de % et échapper tout caractère % littéral. Utilisez likequery pour gérer automatiquement cette conversion, sans implémenter la logique d'échappement dans votre application.

  • Paramètre : Une chaîne unique.

  • Valeur de retour : Une chaîne de recherche compatible avec LIKE, où % est ajouté avant et après le mot-clé, et les caractères % littéraux sont échappés avec \.

postgres=> SELECT likequery('pg_bigm has improved the full text search performance by 200%');
                             likequery
-------------------------------------------------------------------
 %pg\_bigm has improved the full text search performance by 200\%%
(1 row)

postgres=> SELECT * FROM pg_tools WHERE description LIKE likequery('search');
  tool   |                             description
---------+---------------------------------------------------------------------
 pg_bigm | Tool that provides 2-gram full text search capability in PostgreSQL
 pg_trgm | Tool that provides 3-gram full text search capability in PostgreSQL
(2 rows)

show_bigm

Renvoie un tableau contenant tous les éléments de 2-grammes pour une chaîne donnée. La fonction ajoute un espace avant et après la chaîne avant de calculer les sous-chaînes de 2-grammes.

  • Paramètre : Une chaîne unique.

  • Valeur de retour : Un tableau de toutes les sous-chaînes de 2-grammes.

postgres=> SELECT show_bigm('full text search');
                            show_bigm
------------------------------------------------------------------
 {" f"," s"," t",ar,ch,ea,ex,fu,"h ","l ",ll,rc,se,"t ",te,ul,xt}
(1 row)

bigm_similarity

Calcule la similarité entre deux chaînes en se basant sur leurs éléments de 2-grammes communs.

  • Paramètres : Deux chaînes.

  • Valeur de retour : Un nombre à virgule flottante compris entre 0 et 1. 0 signifie que les chaînes sont complètement différentes et 1 qu'elles sont identiques.

Remarque

Étant donné que des espaces sont ajoutés avant et après les chaînes lors du calcul des 2-grammes, la similarité entre ABC et B est de 0, tandis que celle entre ABC et A est de 0,25. La fonction respecte la casse : la similarité entre ABC et abc est donc de 0.

postgres=> SELECT bigm_similarity('full text search', 'text similarity search');
 bigm_similarity
-----------------
       0.5714286
(1 row)

postgres=> SELECT bigm_similarity('ABC', 'A');
 bigm_similarity
-----------------
            0.25
(1 row)

postgres=> SELECT bigm_similarity('ABC', 'B');
 bigm_similarity
-----------------
               0
(1 row)

postgres=> SELECT bigm_similarity('ABC', 'abc');
 bigm_similarity
-----------------
               0
(1 row)

pg_gin_pending_stats

Renvoie le nombre de pages et de tuples dans la liste en attente d'un index GIN.

  • Paramètre : Le nom ou l'OID de l'index GIN.

  • Valeurs de retour : Le nombre de pages et le nombre de tuples dans la liste en attente.

Remarque

Si l'index GIN a été créé avec FASTUPDATE = false, aucune liste en attente n'existe et la fonction renvoie 0.

postgres=> SELECT * FROM pg_gin_pending_stats('pg_tools_idx');
 pages | tuples
-------+--------
     0 |      0
(1 row)

Paramètres

Paramètre Description Par défaut
pg_bigm.last_update Date de la dernière mise à jour de l'extension. Lecture seule. —
pg_bigm.enable_recheck Contrôle si une revérification est effectuée après une analyse d'index GIN. Laissez ce paramètre défini sur on pour obtenir des résultats précis. on
pg_bigm.gin_key_limit Nombre maximal d'éléments de 2-grammes utilisés lors d'une recherche en texte intégral. Définissez-le sur 0 pour utiliser tous les éléments. Réduisez cette valeur si l'utilisation de tous les éléments dégrade les performances. 0
pg_bigm.similarity_limit Seuil de similarité pour la recherche par similarité. Seuls les tuples dont le score de similarité dépasse ce seuil sont renvoyés. —

pg_bigm.last_update

SHOW pg_bigm.last_update;

pg_bigm.enable_recheck

Lorsque enable_recheck est défini sur on (valeur par défaut), les résultats de l'analyse de l'index GIN sont revérifiés par rapport à la condition de requête réelle, ce qui permet de filtrer les faux positifs.

L'exemple suivant illustre cette différence. Avec enable_recheck = off, le mot « trivial » est incorrectement renvoyé lors d'une recherche pour « trial », car ces deux termes partagent les mêmes éléments de 2-grammes :

postgres=> CREATE TABLE tbl (doc text);
CREATE TABLE
postgres=> INSERT INTO tbl VALUES('He is awaiting trial');
INSERT 0 1
postgres=> INSERT INTO tbl VALUES('It was a trivial mistake');
INSERT 0 1
postgres=> CREATE INDEX tbl_idx ON tbl USING gin (doc gin_bigm_ops);
CREATE INDEX
postgres=> SET enable_seqscan TO off;
SET

postgres=> EXPLAIN ANALYZE SELECT * FROM tbl WHERE doc LIKE likequery('trial');
                                                           QUERY PLAN
-----------------------------------------------------------------------------------------------------------------
 Bitmap Heap Scan on tbl  (cost=20.00..24.01 rows=1 width=32) (actual time=0.020..0.021 rows=1 loops=1)
   Recheck Cond: (doc ~~ '%trial%'::text)
   Rows Removed by Index Recheck: 1
   Heap Blocks: exact=1
   ->  Bitmap Index Scan on tbl_idx  (cost=0.00..20.00 rows=1 width=0) (actual time=0.013..0.013 rows=2 loops=1)
         Index Cond: (doc ~~ '%trial%'::text)
 Planning Time: 0.117 ms
 Execution Time: 0.043 ms
(8 rows)

-- With enable_recheck = on (default): correct result
postgres=> SELECT * FROM tbl WHERE doc LIKE likequery('trial');
         doc
----------------------
 He is awaiting trial
(1 row)

-- With enable_recheck = off: false positive included
postgres=> SET pg_bigm.enable_recheck = off;
SET
postgres=> SELECT * FROM tbl WHERE doc LIKE likequery('trial');
           doc
--------------------------
 He is awaiting trial
 It was a trivial mistake
(2 rows)

pg_bigm.gin_key_limit

pg_bigm.similarity_limit

-- Return matches with similarity above 0.2
SET pg_bigm.similarity_limit TO 0.2;