Tous les produits
Search

Ce produit

    PolarDB:Utiliser l'extension pg_roaringbitmap

    Centre de documentation

    PolarDB:Utiliser l'extension pg_roaringbitmap

    Dernière mise à jour :Sep 02, 2026

    L'extension pg_roaringbitmap ajoute le type de données roaringbitmap à PolarDB for PostgreSQL, permettant d'effectuer des opérations sur les bitmaps directement en SQL avec une grande efficacité. Les Roaring bitmaps surpassent les formats de bitmap compressés traditionnels tels que WAH, EWAH et Concise. Dans certains scénarios, ils offrent des vitesses d'indexation des centaines de fois supérieures, dépassant même celles des bitmaps non compressés.

    Cas d'utilisation typiques : segmentation des utilisateurs, filtrage basé sur des tags, déduplication et requêtes d'appartenance à un ensemble à grande échelle.

    Prérequis

    Avant de commencer, assurez-vous de disposer des éléments suivants :

    • Une instance PolarDB for PostgreSQL

    • Les autorisations nécessaires pour exécuter CREATE EXTENSION sur la base de données cible

    Activer l'extension

    CREATE EXTENSION IF NOT EXISTS roaringbitmap;

    Vérifiez l'installation :

    SELECT extname, extversion FROM pg_extension WHERE extname = 'roaringbitmap';

    Résultat attendu :

        extname    | extversion
---------------+------------
 roaringbitmap | 0.5
(1 row)

    Démarrage rapide

    Les étapes suivantes décrivent un flux de travail complet : création d'une table, insertion de données bitmap, exécution de calculs et récupération des résultats.

    Étape 1 : Créez une table avec une colonne roaringbitmap.

    CREATE TABLE t1 (id integer, bitmap roaringbitmap);

    Étape 2 : Insérez des données bitmap.

    -- rb_build: sets bits at the positions listed in the integer array
INSERT INTO t1 SELECT 1, rb_build(ARRAY[1,2,3,4,5,6,7,8,9,200]);

-- rb_build_agg: aggregates multiple row values into a single bitmap,
-- setting a bit for each row value
INSERT INTO t1 SELECT 2, rb_build_agg(e) FROM generate_series(1,100) e;

    Étape 3 : Exécutez des calculs sur les bitmaps (OR, AND, XOR, ANDNOT).

    SELECT roaringbitmap('{1,2,3}') | roaringbitmap('{3,4,5}');  -- OR
SELECT roaringbitmap('{1,2,3}') & roaringbitmap('{3,4,5}');  -- AND
SELECT roaringbitmap('{1,2,3}') # roaringbitmap('{3,4,5}');  -- XOR
SELECT roaringbitmap('{1,2,3}') - roaringbitmap('{3,4,5}');  -- ANDNOT

    Étape 4 : Exécutez des calculs d'agrégation sur les bitmaps.

    SELECT rb_or_agg(bitmap)  FROM t1;
SELECT rb_and_agg(bitmap) FROM t1;
SELECT rb_xor_agg(bitmap) FROM t1;
SELECT rb_build_agg(e)    FROM generate_series(1,100) e;

    Étape 5 : Obtenez la cardinalité (nombre de bits définis).

    SELECT rb_cardinality('{1,2,3}');

    Étape 6 : Récupérez les valeurs entières stockées dans un bitmap.

    -- Convert to an integer array
SELECT rb_to_array(bitmap) FROM t1 WHERE id = 1;

-- Expand to a set of rows
SELECT unnest(rb_to_array('{1,2,3}'::roaringbitmap));

-- Alternatively, use rb_iterate
SELECT rb_iterate('{1,2,3}'::roaringbitmap);

    Formats d'entrée et de sortie

    PolarDB prend en charge les formats array et bytea pour l'entrée et la sortie.

    Entrée

    -- array input
SELECT roaringbitmap('{1,100,10}');
--                    roaringbitmap
-- ------------------------------------------------
--  \x3a30000001000000000002001000000001000a006400

-- bytea input
SELECT '\x3a30000001000000000002001000000001000a006400'::roaringbitmap;
--                    roaringbitmap
-- ------------------------------------------------
--  \x3a30000001000000000002001000000001000a006400

    Sortie

    Le format de sortie par défaut est bytea. Utilisez roaringbitmap.output_format pour changer de format.

    -- Switch to array output
SET roaringbitmap.output_format = 'array';
SELECT '{1}'::roaringbitmap;
--  roaringbitmap
-- ---------------
--  {1}

-- Switch back to bytea output
SET roaringbitmap.output_format = 'bytea';
SELECT '{1}'::roaringbitmap;
--              roaringbitmap
-- ----------------------------------------
--  \x3a3000000100000000000000100000000100

    Opérateurs

    Tous les opérateurs renvoient un type roaringbitmap sauf si le type de sortie est indiqué comme bool.

    Opérateur

    Entrée

    Sortie

    Description

    Exemple

    Résultat

    &

    roaringbitmap, roaringbitmap

    roaringbitmap

    ET binaire (AND)

    roaringbitmap('{1,2,3}') & roaringbitmap('{3,4,5}')

    {3}

    `

    `

    roaringbitmap, roaringbitmap

    roaringbitmap

    OU binaire (OR)

    `roaringbitmap('{1,2,3}')

    roaringbitmap('{3,4,5}')`

    {1,2,3,4,5}

    `

    `

    roaringbitmap, integer

    roaringbitmap

    Ajouter un élément

    `roaringbitmap('{1,2,3}')

    6`

    {1,2,3,6}

    `

    `

    integer, roaringbitmap

    roaringbitmap

    Ajouter un élément

    `6

    roaringbitmap('{1,2,3}')`

    {1,2,3,6}

    #

    roaringbitmap, roaringbitmap

    roaringbitmap

    OU exclusif binaire (XOR)

    roaringbitmap('{1,2,3}') # roaringbitmap('{3,4,5}')

    {1,2,4,5}

    <<

    roaringbitmap, bigint

    roaringbitmap

    Décalage binaire vers la gauche

    roaringbitmap('{1,2,3}') << 2

    {0,1}

    >>

    roaringbitmap, bigint

    roaringbitmap

    Décalage binaire vers la droite

    roaringbitmap('{1,2,3}') >> 3

    {4,5,6}

    -

    roaringbitmap, roaringbitmap

    roaringbitmap

    ANDNOT (différence)

    roaringbitmap('{1,2,3}') - roaringbitmap('{3,4,5}')

    {1,2}

    -

    roaringbitmap, integer

    roaringbitmap

    Supprimer un élément

    roaringbitmap('{1,2,3}') - 3

    {1,2}

    @>

    roaringbitmap, roaringbitmap

    bool

    Contient

    roaringbitmap('{1,2,3}') @> roaringbitmap('{3,4,5}')

    f

    @>

    roaringbitmap, integer

    bool

    Contient l'élément

    roaringbitmap('{1,2,3,4,5}') @> 3

    t

    @>

    roaringbitmap, integer

    bool

    Contient l'élément

    roaringbitmap('{1,2,3}') @> 4

    f

    @>

    integer, roaringbitmap

    bool

    Contient

    3 @> roaringbitmap('{1,2,3,4,5}')

    t

    &&

    roaringbitmap, roaringbitmap

    bool

    Intersection (ET logique)

    roaringbitmap('{1,2,3}') && roaringbitmap('{3,4,5}')

    t

    =

    roaringbitmap, roaringbitmap

    bool

    Égal à

    roaringbitmap('{1,2,3}') = roaringbitmap('{3,4,5}')

    f

    <>

    roaringbitmap, roaringbitmap

    bool

    Différent de

    roaringbitmap('{1,2,3}') <> roaringbitmap('{3,4,5}')

    t

    Fonctions

    Fonctions utilitaires

    Fonction

    Entrée

    Sortie

    Description

    Exemple

    Résultat

    rb_build

    integer[]

    roaringbitmap

    Créer un bitmap à partir d'un tableau d'entiers

    rb_build('{1,2,3,4,5}')

    {1,2,3,4,5}

    rb_index

    roaringbitmap, integer

    bigint

    Renvoyer l'index (base 0) d'un élément, ou -1 s'il n'existe pas

    rb_index('{1,2,3}', 3)

    2

    rb_cardinality

    roaringbitmap

    bigint

    Renvoyer la cardinalité

    rb_cardinality('{1,2,3,4,5}')

    5

    rb_and_cardinality

    roaringbitmap, roaringbitmap

    bigint

    Cardinalité du ET (AND) de deux bitmaps

    rb_and_cardinality('{1,2,3}', rb_build('{3,4,5}'))

    1

    rb_or_cardinality

    roaringbitmap, roaringbitmap

    bigint

    Cardinalité du OU (OR) de deux bitmaps

    rb_or_cardinality('{1,2,3}', '{3,4,5}')

    5

    rb_xor_cardinality

    roaringbitmap, roaringbitmap

    bigint

    Cardinalité du OU exclusif (XOR) de deux bitmaps

    rb_xor_cardinality('{1,2,3}', '{3,4,5}')

    4

    rb_andnot_cardinality

    roaringbitmap, roaringbitmap

    bigint

    Cardinalité du ANDNOT de deux bitmaps

    rb_andnot_cardinality('{1,2,3}', '{3,4,5}')

    2

    rb_is_empty

    roaringbitmap

    boolean

    Vérifier si le bitmap est vide

    rb_is_empty('{1,2,3,4,5}')

    f

    rb_fill

    roaringbitmap, range_start bigint, range_end bigint

    roaringbitmap

    Ajouter tous les entiers dans [range_start, range_end)

    rb_fill('{1,2,3}', 5, 7)

    {1,2,3,5,6}

    rb_clear

    roaringbitmap, range_start bigint, range_end bigint

    roaringbitmap

    Supprimer tous les entiers dans [range_start, range_end)

    rb_clear('{1,2,3}', 2, 3)

    {1,3}

    rb_flip

    roaringbitmap, range_start bigint, range_end bigint

    roaringbitmap

    Inverser tous les bits dans [range_start, range_end)

    rb_flip('{1,2,3}', 2, 10)

    {1,4,5,6,7,8,9}

    rb_range

    roaringbitmap, range_start bigint, range_end bigint

    roaringbitmap

    Renvoyer les éléments dans [range_start, range_end)

    rb_range('{1,2,3}', 2, 3)

    {2}

    rb_range_cardinality

    roaringbitmap, range_start bigint, range_end bigint

    bigint

    Cardinalité des éléments dans [range_start, range_end)

    rb_range_cardinality('{1,2,3}', 2, 3)

    1

    rb_min

    roaringbitmap

    integer

    Petit élément ; NULL si vide

    rb_min('{1,2,3}')

    1

    rb_max

    roaringbitmap

    integer

    Plus grand élément ; NULL si vide

    rb_max('{1,2,3}')

    3

    rb_rank

    roaringbitmap, integer

    bigint

    Nombre d'éléments inférieurs ou égaux à la valeur donnée

    rb_rank('{1,2,3}', 3)

    3

    rb_jaccard_dist

    roaringbitmap, roaringbitmap

    double precision

    Distance de Jaccard (coefficient de similarité de Jaccard) de deux bitmaps

    rb_jaccard_dist('{1,2,3}', '{3,4}')

    0.25

    rb_select

    roaringbitmap, bitset_limit bigint, bitset_offset bigint=0, reverse boolean=false, range_start bigint=0, range_end bigint=4294967296

    roaringbitmap

    Renvoyer le sous-ensemble [offset, offset+limit) des éléments dans [range_start, range_end)

    rb_select('{1,2,3,4,5,6,7,8,9}', 5, 2)

    {3,4,5,6,7}

    rb_to_array

    roaringbitmap

    integer[]

    Convertir en tableau d'entiers

    rb_to_array(roaringbitmap('{1,2,3}'))

    {1,2,3}

    rb_iterate

    roaringbitmap

    SET of integer

    Renvoyer les éléments sous forme d'ensemble de lignes

    SELECT rb_iterate(rb_build('{1,2,3}'))

    1, 2, 3

    Fonctions d'agrégation

    Fonction

    Entrée

    Sortie

    Description

    Exemple

    Résultat

    rb_build_agg

    integer

    roaringbitmap

    Construire un bitmap à partir d'un ensemble de lignes d'entiers

    SELECT rb_build_agg(id) FROM (VALUES (1),(2),(3)) t(id)

    {1,2,3}

    rb_or_agg

    roaringbitmap

    roaringbitmap

    Agrégation OU (OR) sur un ensemble de bitmaps

    SELECT rb_or_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)

    {1,2,3,4}

    rb_and_agg

    roaringbitmap

    roaringbitmap

    Agrégation ET (AND) sur un ensemble de bitmaps

    SELECT rb_and_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)

    {2,3}

    rb_xor_agg

    roaringbitmap

    roaringbitmap

    Agrégation OU exclusif (XOR) sur un ensemble de bitmaps

    SELECT rb_xor_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)

    {1,4}

    rb_or_cardinality_agg

    roaringbitmap

    bigint

    Agrégation OU (OR), renvoie la cardinalité

    SELECT rb_or_cardinality_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)

    4

    rb_and_cardinality_agg

    roaringbitmap

    bigint

    Agrégation ET (AND), renvoie la cardinalité

    SELECT rb_and_cardinality_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)

    2

    rb_xor_cardinality_agg

    roaringbitmap

    bigint

    Agrégation OU exclusif (XOR), renvoie la cardinalité

    SELECT rb_xor_cardinality_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)

    2