ApsaraDB for SelectDB:Déduplication précise avec BITMAP

Scan (Node 1)              Scan (Node 2)
+---------+---------+      +---------+---------+
| user_id | tag     |      | user_id | tag     |
+---------+---------+      +---------+---------+
| 1       | A       |      | 3       | A       |
| 2       | B       |      | 4       | C       |
+---------+---------+      +---------+---------+
         |                          |
         +----------+  +-----------+
                    |  |
             Top-level node
         Receives ALL distinct values
         from every node, merges them
         (bottleneck: I/O + single-node compute)

Stage 1 (distributed): each bucket computes intersection/union locally
Stage 2 (merge): top-level node combines per-bucket results (small data only)

Étape 1 : Création de la table

Créez une table basée sur le modèle Aggregate Key, incluant un champ Value de type bitmap ainsi qu'une colonne hid pour le hachage par buckets.

CREATE TABLE `user_tag_bitmap` (
  `tag`     BIGINT(20)  NULL COMMENT "User tag",
  `hid`     SMALLINT(6) NULL COMMENT "Bucket ID",
  `user_id` BITMAP BITMAP_UNION NULL COMMENT "User bitmap"
) ENGINE=OLAP
AGGREGATE KEY(`tag`, `hid`)
COMMENT "OLAP"
DISTRIBUTED BY HASH(`hid`) BUCKETS 3;

La colonne hid divise la plage des user_id en groupes, chacun étant attribué à un bucket spécifique. Cela garantit l'orthogonalité des valeurs de bitmap entre les différents buckets.

Étape 2 : Importation des données

Utilisez une instruction LOAD LABEL pour charger les données. L'expression ceil(tmp_user_id/500) calcule la valeur hid pour chaque ligne, tandis que to_bitmap(tmp_user_id) convertit l'entier brut en une entrée bitmap.

LOAD LABEL user_tag_bitmap_test
(
    DATA INFILE('hdfs://abc')
    INTO TABLE user_tag_bitmap
    COLUMNS TERMINATED BY ','
    (tmp_tag, tmp_user_id)
    SET (
        tag     = tmp_tag,
        hid     = ceil(tmp_user_id/500),
        user_id = to_bitmap(tmp_user_id)
    )
)

Les données source se présentent sous la forme de deux colonnes séparées par des virgules : le tag et l'ID utilisateur.

11111111,1
11111112,2
11111113,3
11111114,4

Lors de l'importation, SelectDB attribue la même valeur hid aux ID utilisateur compris dans la plage [1, 5000000) et les place dans le même bucket. Les valeurs de bitmap restent orthogonales d'un bucket à l'autre, ce qui réduit le coût de calcul des opérations d'intersection et d'union.

Étape 3 : Interrogation avec les fonctions de bitmap orthogonal

Une fois les données importées, utilisez les fonctions de bitmap orthogonal décrites dans la section suivante. Pour consulter la liste complète des fonctions bitmap standard, reportez-vous à la référence SQL.

bitmap_orthogonal_intersect

Calcule l'intersection des valeurs de bitmap pour les valeurs de filtre spécifiées et renvoie le résultat sous forme de bitmap.

Syntaxe

bitmap_orthogonal_intersect(bitmap_column, column_to_filter, filter_values)

Paramètres

Exemple

SELECT BITMAP_COUNT(bitmap_orthogonal_intersect(user_id, tag, 13080800, 11110200))
FROM user_tag_bitmap
WHERE tag IN (13080800, 11110200);

Équivalent à :

-- Returns the count of users who appear in ALL specified tags
SELECT COUNT(DISTINCT user_id)
FROM user_tag_bitmap
WHERE tag IN (13080800, 11110200)
  AND <user_id appears in every tag>;

Lors de l'exécution, l'étape 1 filtre les lignes selon les tags spécifiés, puis calcule l'intersection des bitmaps pour tous les tags correspondants au sein de chaque bucket. L'étape 2 fusionne itérativement les bitmaps d'intersection de chaque bucket pour obtenir le résultat final.

orthogonal_bitmap_intersect_count

Calcule l'intersection des valeurs de bitmap et renvoie directement le décompte. La sémantique correspond à celle de intersect_count, mais l'exécution est distribuée entre les buckets.La syntaxe est identique à celle de la fonction intersect_count, mais l'implémentation diffère.La syntaxe est identique à celle de la fonction bitmap_union_count, mais l'implémentation diffère.

Syntaxe

orthogonal_bitmap_intersect_count(bitmap_column, column_to_filter, filter_values)

Paramètres

Exemple

SELECT orthogonal_bitmap_intersect_count(user_id, tag, 1150000, 1150001, 390006)
FROM user_tag_bitmap
WHERE tag IN (1150000, 1150001, 390006);

Durant l'exécution, l'étape 1 applique le filtre sur les tags spécifiés, calcule l'intersection des bitmaps pour tous les tags correspondants, puis effectue le décompte par bucket. L'étape 2 additionne tous les comptes partiels pour produire le total final.

orthogonal_bitmap_union_count

Calcule l'union des valeurs de bitmap et renvoie le décompte. Bien que la sémantique soit identique à BITMAP_UNION_COUNT, l'exécution est ici distribuée entre les buckets.

Syntaxe

orthogonal_bitmap_union_count(bitmap_column)

Paramètres

Exemple

SELECT orthogonal_bitmap_union_count(user_id)
FROM user_tag_bitmap
WHERE tag IN (1150000, 1150001, 390006);

Équivalent à :

SELECT COUNT(DISTINCT user_id)
FROM user_tag_bitmap
WHERE tag IN (1150000, 1150001, 390006);

Pendant l'exécution, l'étape 1 réalise l'union des bitmaps par bucket et compte le résultat obtenu. L'étape 2 somme ensuite l'ensemble des comptes partiels pour fournir le total définitif.

orthogonal_bitmap_expr_calculate

Évalue une expression ensembliste sur des colonnes bitmap et retourne le résultat sous forme de bitmap. Privilégiez cette fonction lorsque vous avez besoin du bitmap lui-même pour un traitement ultérieur, plutôt que d'un simple décompte.

Syntaxe

orthogonal_bitmap_expr_calculate(bitmap_column, filter_column, input_string)

Paramètres

input_string prend en charge les opérateurs suivants :

Exemple

SELECT orthogonal_bitmap_expr_calculate(
    user_id,
    tag,
    '(833736|999777)&(1308083|231207)&(1000|20000-30000)'
)
FROM user_tag_bitmap
WHERE tag IN (833736, 999777, 130808, 231207, 1000, 20000, 30000);

Au cours de l'exécution, l'étape 1 analyse input_string pour déterminer le filtre de tags, filtre les données, puis applique l'expression bitmap aux lignes filtrées de chaque bucket. L'étape 2 calcule l'union de tous les résultats bitmap par bucket et renvoie le bitmap final.

orthogonal_bitmap_expr_calculate_count

Évalue une expression ensembliste sur des colonnes bitmap et renvoie le décompte. La syntaxe et les paramètres sont strictement identiques à ceux de orthogonal_bitmap_expr_calculate.

Syntaxe

orthogonal_bitmap_expr_calculate_count(bitmap_column, filter_column, input_string)

Paramètres

Exemple

SELECT orthogonal_bitmap_expr_calculate_count(
    user_id,
    tag,
    '(833736|999777)&(1308083|231207)&(1000|20000-30000)'
)
FROM user_tag_bitmap
WHERE tag IN (833736, 999777, 130808, 231207, 1000, 20000, 30000);

Lors de l'exécution, l'étape 1 analyse input_string, filtre les données, applique l'expression bitmap et compte le résultat pour chaque bucket. L'étape 2 calcule l'union de tous les résultats bitmap par bucket et retourne le décompte final.