o que é varbitx, como usar - PolarDB: Central de Documentação do Alibaba Cloud

O varbitx é uma extensão do PolarDB for PostgreSQL que adiciona funções avançadas de operação com cadeias de bits, além daquelas fornecidas pela extensão padrão varbit do PostgreSQL. Use esta extensão para manipulação de bits de alto desempenho em cenários como marcação de perfis de usuário em tempo real, controle de acesso publicitário e sistemas de bilhetagem.

Pré-requisitos

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

Um cluster do PolarDB for PostgreSQL executando o PostgreSQL 11

Instale a extensão

CREATE EXTENSION varbitx;

Para remover a extensão:

DROP EXTENSION varbitx;

Funções

Todas as funções aceitam e retornam valores varbit padrão do PostgreSQL. As posições dos bits usam indexação baseada em zero (o bit mais à esquerda corresponde à posição 0).

Extração de bits

Função	Descrição	Exemplo
`get_bit(bits varbit, start int, count int) returns varbit`	Retorna `count` bits a partir da posição `start`.	`get_bit('111110000011', 3, 5)` → `11000`
`get_bit_array(bits varbit, start int, count int, value int) returns int[]`	Obtém `count` bits a partir de `start` e retorna as posições dos bits iguais a `value` (0 ou 1).	`get_bit_array('111110000011', 3, 5, 1)` → `[3,4]`
`get_bit_array(bits varbit, value int, positions int[]) returns int[]`	Considerando os bits nas `positions` especificadas, retorna as posições dos bits iguais a `value` (0 ou 1). Bits não listados em `positions` são ignorados.	`get_bit_array('111110000011', 1, array[1,5,6,7,10,11])` → `[1,10,11]`

Modificação de bits

Função	Descrição	Exemplo
`set_bit_array(bits varbit, value int, fill int, positions int[]) returns varbit`	Defina os bits nas `positions` fornecidas como `value` (0 ou 1). Estende a cadeia de bits conforme necessário e preenche os novos bits com `fill` (0 ou 1).	`set_bit_array('111100001111', 0, 1, array[1,15])` → `1011000011111110`
`set_bit_array(bits varbit, value int, fill int, positions int[], limit int) returns varbit`	Igual à anterior, mas interrompe o processamento após atingir `limit` posições.	`set_bit_array('111100001111', 1, 0, array[4,5,6,7], 2)` → `111111001111`
`set_bit_array_record(bits varbit, value int, fill int, positions int[]) returns (varbit, int[])`	Defina os bits nas `positions` indicadas como `value` (0 ou 1), estende a cadeia com `fill` se necessário e retorna tanto a cadeia de bits atualizada quanto as posições alteradas.	`set_bit_array_record('111100001111', 0, 1, array[1,15])` → `1011000011111110`, `[1,15]`
`set_bit_array_record(bits varbit, value int, fill int, positions int[], limit int) returns (varbit, int[])`	Semelhante à função acima, mas para após alterar `limit` bits. Retorna a cadeia de bits atualizada e as posições efetivamente modificadas.	`set_bit_array_record('111100001111', 1, 0, array[1,4,5,6,7], 2)` → `111111001111`, `[4,5]`

Geração de bits

Função	Descrição	Exemplo
`bit_fill(value int, count int) returns varbit`	Retorna uma cadeia de bits com `count` bits, todos definidos como `value` (0 ou 1).	`bit_fill(0, 10)` → `0000000000`
`bit_rand(count int, value int, ratio float) returns varbit`	Gera uma cadeia de `count` bits em que aproximadamente `ratio` dos bits são definidos como `value` (0 ou 1), distribuídos aleatoriamente.	`bit_rand(10, 1, 0.3)` pode retornar `0101000001`

Contagem de bits

Função	Descrição	Exemplo
`bit_count(bits varbit, value int) returns int`	Conta todos os bits iguais a `value` (0 ou 1).	`bit_count('1111000011110000', 1)` → `8`
`bit_count(bits varbit, value int, start int, count int) returns int`	Conta bits iguais a `value` dentro de `count` bits a partir de `start`. Bits além do comprimento da cadeia não são considerados.	`bit_count('1111000011110000', 1, 5, 4)` → `1`
`bit_count_array(bits varbit, value int, positions int[]) returns int`	Conta quantos bits nas `positions` especificadas são iguais a `value` (0 ou 1).	`bit_count_array('1111000011110000', 1, array[1,2,7,8])` → `3`

Consulta de posições

Função	Descrição	Exemplo
`bit_posite(bits varbit, value int, ascending boolean) returns int[]`	Lista as posições de todos os bits iguais a `value` (0 ou 1). Use `true` para ordem crescente e `false` para decrescente.	`bit_posite('11110010011', 1, true)` → `[0,1,2,3,6,9,10]`; `bit_posite('11110010011', 1, false)` → `[10,9,6,3,2,1,0]`
`bit_posite(bits varbit, value int, limit int, ascending boolean) returns int[]`	Retorna até `limit` posições de bits iguais a `value` (0 ou 1). Use `true` para ordem crescente ou `false` para decrescente.	`bit_posite('11110010011', 1, 3, true)` → `[0,1,2]`; `bit_posite('11110010011', 1, 3, false)` → `[10,9,6]`

Exemplos de uso

Os exemplos abaixo demonstram um fluxo de trabalho típico para um sistema de marcação de usuários: crie uma tabela com uma coluna varbit, insira dados e consulte-os usando as funções do varbitx.

Crie uma tabela com coluna varbit

CREATE TABLE user_tags (
    user_id   integer,
    tag_bits  varbit
);

Inserir dados varbit

INSERT INTO user_tags VALUES (1, '1111000011110000');
INSERT INTO user_tags VALUES (2, '1011000011111110');
INSERT INTO user_tags VALUES (3, '0000111100001111');

Contar tags ativas por usuário

Conte os bits definidos como 1 (tags ativas) para cada usuário:

SELECT user_id, bit_count(tag_bits, 1) AS active_tag_count
FROM user_tags;

Saída esperada:

 user_id | active_tag_count
---------+------------------
       1 |                8
       2 |               10
       3 |                8
(3 rows)

Filtrar usuários pela posição da tag

Encontre os usuários que têm a tag na posição 0 definida:

SELECT user_id
FROM user_tags
WHERE get_bit(tag_bits, 0, 1) = B'1';

Ative tags específicas e registrar alterações

Use set_bit_array_record para ativar tags em posições específicas e obter as posições alteradas:

SELECT user_id,
       set_bit_array_record(tag_bits, 1, 0, array[1,4,5,6,7], 2)
FROM user_tags
WHERE user_id = 1;

Saída esperada:

 user_id | set_bit_array_record
---------+----------------------
       1 | (1111110011110000,"{4,5}")
(1 row)