All Products
Search
Document Center

PolarDB:pg_roaringbitmap

Last Updated:Mar 28, 2026

The pg_roaringbitmap extension adds the roaringbitmap data type to PolarDB for PostgreSQL, enabling efficient bitmap operations directly in SQL. Roaring bitmaps outperform traditional compressed bitmap formats such as WAH, EWAH, and Concise—in some scenarios delivering indexing speeds hundreds of times faster, and even faster than uncompressed bitmaps.

Typical use cases: user segmentation, tag-based filtering, deduplication, and set membership queries at scale.

Prerequisites

Before you begin, make sure you have:

  • A PolarDB for PostgreSQL instance

  • Permission to run CREATE EXTENSION on the target database

Enable the extension

CREATE EXTENSION IF NOT EXISTS roaringbitmap;

Verify the installation:

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

Expected output:

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

Quick start

The following steps walk through a complete workflow: create a table, insert bitmap data, run calculations, and retrieve results.

Step 1: Create a table with a `roaringbitmap` column.

CREATE TABLE t1 (id integer, bitmap roaringbitmap);

Step 2: Insert bitmap data.

-- 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;

Step 3: Run bitmap calculations (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

Step 4: Run bitmap aggregate calculations.

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;

Step 5: Get the cardinality (count of set bits).

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

Step 6: Retrieve the integer values stored in a 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);

Input and output formats

PolarDB supports array and bytea as input and output formats.

Input

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

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

Output

The default output format is bytea. Use roaringbitmap.output_format to switch formats.

-- 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

Operators

All operators return roaringbitmap unless the output type is listed as bool.

OperatorInputOutputDescriptionExampleResult
&roaringbitmap, roaringbitmaproaringbitmapBitwise ANDroaringbitmap('{1,2,3}') & roaringbitmap('{3,4,5}'){3}
|roaringbitmap, roaringbitmaproaringbitmapBitwise ORroaringbitmap('{1,2,3}') | roaringbitmap('{3,4,5}'){1,2,3,4,5}
|roaringbitmap, integerroaringbitmapAdd elementroaringbitmap('{1,2,3}') | 6{1,2,3,6}
|integer, roaringbitmaproaringbitmapAdd element6 | roaringbitmap('{1,2,3}'){1,2,3,6}
#roaringbitmap, roaringbitmaproaringbitmapBitwise XORroaringbitmap('{1,2,3}') # roaringbitmap('{3,4,5}'){1,2,4,5}
<<roaringbitmap, bigintroaringbitmapBitwise left shiftroaringbitmap('{1,2,3}') << 2{0,1}
>>roaringbitmap, bigintroaringbitmapBitwise right shiftroaringbitmap('{1,2,3}') >> 3{4,5,6}
-roaringbitmap, roaringbitmaproaringbitmapANDNOT (difference)roaringbitmap('{1,2,3}') - roaringbitmap('{3,4,5}'){1,2}
-roaringbitmap, integerroaringbitmapRemove elementroaringbitmap('{1,2,3}') - 3{1,2}
@>roaringbitmap, roaringbitmapboolContainsroaringbitmap('{1,2,3}') @> roaringbitmap('{3,4,5}')f
@>roaringbitmap, integerboolContains elementroaringbitmap('{1,2,3,4,5}') @> 3t
@>roaringbitmap, integerboolContains elementroaringbitmap('{1,2,3}') @> 4f
@>integer, roaringbitmapboolContains3 @> roaringbitmap('{1,2,3,4,5}')t
&&roaringbitmap, roaringbitmapboolIntersects (logical AND)roaringbitmap('{1,2,3}') && roaringbitmap('{3,4,5}')t
=roaringbitmap, roaringbitmapboolEqualroaringbitmap('{1,2,3}') = roaringbitmap('{3,4,5}')f
<>roaringbitmap, roaringbitmapboolNot equalroaringbitmap('{1,2,3}') <> roaringbitmap('{3,4,5}')t

Functions

Functionality functions

FunctionInputOutputDescriptionExampleResult
rb_buildinteger[]roaringbitmapCreate a bitmap from an integer arrayrb_build('{1,2,3,4,5}'){1,2,3,4,5}
rb_indexroaringbitmap, integerbigintReturn the 0-based index of an element, or -1 if it does not existrb_index('{1,2,3}', 3)2
rb_cardinalityroaringbitmapbigintReturn the cardinalityrb_cardinality('{1,2,3,4,5}')5
rb_and_cardinalityroaringbitmap, roaringbitmapbigintCardinality of the AND of two bitmapsrb_and_cardinality('{1,2,3}', rb_build('{3,4,5}'))1
rb_or_cardinalityroaringbitmap, roaringbitmapbigintCardinality of the OR of two bitmapsrb_or_cardinality('{1,2,3}', '{3,4,5}')5
rb_xor_cardinalityroaringbitmap, roaringbitmapbigintCardinality of the XOR of two bitmapsrb_xor_cardinality('{1,2,3}', '{3,4,5}')4
rb_andnot_cardinalityroaringbitmap, roaringbitmapbigintCardinality of the ANDNOT of two bitmapsrb_andnot_cardinality('{1,2,3}', '{3,4,5}')2
rb_is_emptyroaringbitmapbooleanCheck if the bitmap is emptyrb_is_empty('{1,2,3,4,5}')f
rb_fillroaringbitmap, range_start bigint, range_end bigintroaringbitmapAdd all integers in [range_start, range_end)rb_fill('{1,2,3}', 5, 7){1,2,3,5,6}
rb_clearroaringbitmap, range_start bigint, range_end bigintroaringbitmapRemove all integers in [range_start, range_end)rb_clear('{1,2,3}', 2, 3){1,3}
rb_fliproaringbitmap, range_start bigint, range_end bigintroaringbitmapNegate all bits in [range_start, range_end)rb_flip('{1,2,3}', 2, 10){1,4,5,6,7,8,9}
rb_rangeroaringbitmap, range_start bigint, range_end bigintroaringbitmapReturn elements in [range_start, range_end)rb_range('{1,2,3}', 2, 3){2}
rb_range_cardinalityroaringbitmap, range_start bigint, range_end bigintbigintCardinality of elements in [range_start, range_end)rb_range_cardinality('{1,2,3}', 2, 3)1
rb_minroaringbitmapintegerSmallest element; NULL if emptyrb_min('{1,2,3}')1
rb_maxroaringbitmapintegerLargest element; NULL if emptyrb_max('{1,2,3}')3
rb_rankroaringbitmap, integerbigintCount of elements less than or equal to the given valuerb_rank('{1,2,3}', 3)3
rb_jaccard_distroaringbitmap, roaringbitmapdouble precisionJaccard distance (Jaccard similarity coefficient) of two bitmapsrb_jaccard_dist('{1,2,3}', '{3,4}')0.25
rb_selectroaringbitmap, bitset_limit bigint, bitset_offset bigint=0, reverse boolean=false, range_start bigint=0, range_end bigint=4294967296roaringbitmapReturn subset [offset, offset+limit) of elements in [range_start, range_end)rb_select('{1,2,3,4,5,6,7,8,9}', 5, 2){3,4,5,6,7}
rb_to_arrayroaringbitmapinteger[]Convert to an integer arrayrb_to_array(roaringbitmap('{1,2,3}')){1,2,3}
rb_iterateroaringbitmapSET of integerReturn elements as a set of rowsSELECT rb_iterate(rb_build('{1,2,3}'))1, 2, 3

Aggregate functions

FunctionInputOutputDescriptionExampleResult
rb_build_aggintegerroaringbitmapBuild a bitmap from a set of integer rowsSELECT rb_build_agg(id) FROM (VALUES (1),(2),(3)) t(id){1,2,3}
rb_or_aggroaringbitmaproaringbitmapOR aggregate across a set of bitmapsSELECT rb_or_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap){1,2,3,4}
rb_and_aggroaringbitmaproaringbitmapAND aggregate across a set of bitmapsSELECT rb_and_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap){2,3}
rb_xor_aggroaringbitmaproaringbitmapXOR aggregate across a set of bitmapsSELECT rb_xor_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap){1,4}
rb_or_cardinality_aggroaringbitmapbigintOR aggregate, return cardinalitySELECT rb_or_cardinality_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)4
rb_and_cardinality_aggroaringbitmapbigintAND aggregate, return cardinalitySELECT rb_and_cardinality_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)2
rb_xor_cardinality_aggroaringbitmapbigintXOR aggregate, return cardinalitySELECT rb_xor_cardinality_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)2