pg_roaringbitmap - PolarDB: Central de Documentação do Alibaba Cloud

A extensão pg_roaringbitmap adiciona o tipo de dado roaringbitmap ao PolarDB for PostgreSQL, permitindo operações eficientes de bitmap diretamente em SQL. Os roaring bitmaps superam formatos tradicionais de bitmap compactado, como WAH, EWAH e Concise. Em alguns cenários, oferecem velocidades de indexação centenas de vezes mais rápidas, sendo ainda mais velozes que bitmaps não compactados.

Casos de uso típicos: segmentação de usuários, filtragem baseada em tags, deduplicação e consultas de pertinência a conjuntos em grande escala.

Pré-requisitos

Antes de começar, verifique se você possui:

Uma instância do PolarDB for PostgreSQL
Permissão para executar CREATE EXTENSION no banco de dados de destino

Ative a extensão

CREATE EXTENSION IF NOT EXISTS roaringbitmap;

Verifique a instalação:

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

Saída esperada:

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

Início rápido

As etapas a seguir demonstram um fluxo de trabalho completo: criação de tabela, inserção de dados de bitmap, execução de cálculos e recuperação de resultados.

Etapa 1: Crie uma tabela com uma coluna roaringbitmap.

CREATE TABLE t1 (id integer, bitmap roaringbitmap);

Etapa 2: Insira dados de 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;

Etapa 3: Execute cálculos de bitmap (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

Etapa 4: Execute cálculos agregados de bitmap.

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;

Etapa 5: Obtenha a cardinalidade (contagem de bits definidos).

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

Etapa 6: Recupere os valores inteiros armazenados em um 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);

Formatos de entrada e saída

O PolarDB suporta array e bytea como formatos de entrada e saída.

Entrada

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

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

Saída

O formato de saída padrão é bytea. Use roaringbitmap.output_format para alternar entre os formatos.

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

Operadores

Todos os operadores retornam roaringbitmap, exceto quando o tipo de saída estiver listado como bool.

Operador	Entrada	Saída	Descrição	Exemplo	Resultado
`&`	roaringbitmap, roaringbitmap	roaringbitmap	AND bit a bit	`roaringbitmap('{1,2,3}') & roaringbitmap('{3,4,5}')`	`{3}`
`	`	roaringbitmap, roaringbitmap	roaringbitmap	OR bit a bit	`roaringbitmap('{1,2,3}')	roaringbitmap('{3,4,5}')`	`{1,2,3,4,5}`
`	`	roaringbitmap, integer	roaringbitmap	Adiciona elemento	`roaringbitmap('{1,2,3}')	6`	`{1,2,3,6}`
`	`	integer, roaringbitmap	roaringbitmap	Adiciona elemento	`6	roaringbitmap('{1,2,3}')`	`{1,2,3,6}`
`#`	roaringbitmap, roaringbitmap	roaringbitmap	XOR bit a bit	`roaringbitmap('{1,2,3}') # roaringbitmap('{3,4,5}')`	`{1,2,4,5}`
`<<`	roaringbitmap, bigint	roaringbitmap	Deslocamento bit a bit à esquerda	`roaringbitmap('{1,2,3}') << 2`	`{0,1}`
`>>`	roaringbitmap, bigint	roaringbitmap	Deslocamento bit a bit à direita	`roaringbitmap('{1,2,3}') >> 3`	`{4,5,6}`
`-`	roaringbitmap, roaringbitmap	roaringbitmap	ANDNOT (diferença)	`roaringbitmap('{1,2,3}') - roaringbitmap('{3,4,5}')`	`{1,2}`
`-`	roaringbitmap, integer	roaringbitmap	Remove elemento	`roaringbitmap('{1,2,3}') - 3`	`{1,2}`
`@>`	roaringbitmap, roaringbitmap	bool	Contém	`roaringbitmap('{1,2,3}') @> roaringbitmap('{3,4,5}')`	`f`
`@>`	roaringbitmap, integer	bool	Contém elemento	`roaringbitmap('{1,2,3,4,5}') @> 3`	`t`
`@>`	roaringbitmap, integer	bool	Contém elemento	`roaringbitmap('{1,2,3}') @> 4`	`f`
`@>`	integer, roaringbitmap	bool	Contém	`3 @> roaringbitmap('{1,2,3,4,5}')`	`t`
`&&`	roaringbitmap, roaringbitmap	bool	Interseção (AND lógico)	`roaringbitmap('{1,2,3}') && roaringbitmap('{3,4,5}')`	`t`
`=`	roaringbitmap, roaringbitmap	bool	Igual	`roaringbitmap('{1,2,3}') = roaringbitmap('{3,4,5}')`	`f`
`<>`	roaringbitmap, roaringbitmap	bool	Diferente	`roaringbitmap('{1,2,3}') <> roaringbitmap('{3,4,5}')`	`t`

Funções

Funções de funcionalidade

Função	Entrada	Saída	Descrição	Exemplo	Resultado
`rb_build`	integer[]	roaringbitmap	Cria um bitmap a partir de um array de inteiros	`rb_build('{1,2,3,4,5}')`	`{1,2,3,4,5}`
`rb_index`	roaringbitmap, integer	bigint	Retorna o índice base 0 de um elemento, ou -1 se não existir	`rb_index('{1,2,3}', 3)`	`2`
`rb_cardinality`	roaringbitmap	bigint	Retorna a cardinalidade	`rb_cardinality('{1,2,3,4,5}')`	`5`
`rb_and_cardinality`	roaringbitmap, roaringbitmap	bigint	Cardinalidade do AND de dois bitmaps	`rb_and_cardinality('{1,2,3}', rb_build('{3,4,5}'))`	`1`
`rb_or_cardinality`	roaringbitmap, roaringbitmap	bigint	Cardinalidade do OR de dois bitmaps	`rb_or_cardinality('{1,2,3}', '{3,4,5}')`	`5`
`rb_xor_cardinality`	roaringbitmap, roaringbitmap	bigint	Cardinalidade do XOR de dois bitmaps	`rb_xor_cardinality('{1,2,3}', '{3,4,5}')`	`4`
`rb_andnot_cardinality`	roaringbitmap, roaringbitmap	bigint	Cardinalidade do ANDNOT de dois bitmaps	`rb_andnot_cardinality('{1,2,3}', '{3,4,5}')`	`2`
`rb_is_empty`	roaringbitmap	boolean	Verifica se o bitmap está vazio	`rb_is_empty('{1,2,3,4,5}')`	`f`
`rb_fill`	roaringbitmap, range_start bigint, range_end bigint	roaringbitmap	Adiciona todos os inteiros em [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	Remove todos os inteiros em [range_start, range_end)	`rb_clear('{1,2,3}', 2, 3)`	`{1,3}`
`rb_flip`	roaringbitmap, range_start bigint, range_end bigint	roaringbitmap	Nega todos os bits em [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	Retorna elementos em [range_start, range_end)	`rb_range('{1,2,3}', 2, 3)`	`{2}`
`rb_range_cardinality`	roaringbitmap, range_start bigint, range_end bigint	bigint	Cardinalidade dos elementos em [range_start, range_end)	`rb_range_cardinality('{1,2,3}', 2, 3)`	`1`
`rb_min`	roaringbitmap	integer	Menor elemento; NULL se vazio	`rb_min('{1,2,3}')`	`1`
`rb_max`	roaringbitmap	integer	Maior elemento; NULL se vazio	`rb_max('{1,2,3}')`	`3`
`rb_rank`	roaringbitmap, integer	bigint	Contagem de elementos menores ou iguais ao valor fornecido	`rb_rank('{1,2,3}', 3)`	`3`
`rb_jaccard_dist`	roaringbitmap, roaringbitmap	double precision	Distância de Jaccard (coeficiente de similaridade de Jaccard) de dois 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	Retorna subconjunto [offset, offset+limit) de elementos em [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[]	Converte para um array de inteiros	`rb_to_array(roaringbitmap('{1,2,3}'))`	`{1,2,3}`
`rb_iterate`	roaringbitmap	SET of integer	Retorna elementos como um conjunto de linhas	`SELECT rb_iterate(rb_build('{1,2,3}'))`	`1`, `2`, `3`

Funções agregadas

Função	Entrada	Saída	Descrição	Exemplo	Resultado
`rb_build_agg`	integer	roaringbitmap	Constrói um bitmap a partir de um conjunto de linhas inteiras	`SELECT rb_build_agg(id) FROM (VALUES (1),(2),(3)) t(id)`	`{1,2,3}`
`rb_or_agg`	roaringbitmap	roaringbitmap	Agregação OR em um conjunto 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	Agregação AND em um conjunto 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	Agregação XOR em um conjunto 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	Agregação OR, retorna cardinalidade	`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	Agregação AND, retorna cardinalidade	`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	Agregação XOR, retorna cardinalidade	`SELECT rb_xor_cardinality_agg(bitmap) FROM (VALUES (roaringbitmap('{1,2,3}')), (roaringbitmap('{2,3,4}'))) t(bitmap)`	`2`