Gérer les index full-text HBase - ApsaraDB for HBase - Centre de documentation Alibaba Cloud

Un mappage d'index full-text relie une table HBase à un index Search. Chaque mappage définit les colonnes HBase à synchroniser, la méthode d'encodage de la rowkey ainsi que le type de données de chaque colonne. Cette rubrique explique comment créer, mettre à jour et inspecter les mappages à l'aide de HBase Shell.

Prérequis

Avant de commencer, assurez-vous d'avoir :

Consulté le guide Démarrage rapide
Téléchargé et configuré la dernière version de HBase Shell

Créer un mappage

Enregistrez la configuration du mappage dans un fichier JSON et transmettez-le à HBase Shell. L'exemple suivant mappe deux colonnes de testTable vers l'index Search democollection.

{
  "sourceNamespace": "default",
  "sourceTable": "testTable",
  "targetIndexName": "democollection",
  "indexType": "SOLR",
  "rowkeyFormatterType": "STRING",
  "fields": [
    {
      "source": "f:name",
      "targetField": "name_s",
      "type": "STRING"
    },
    {
      "source": "f:age",
      "targetField": "age_i",
      "type": "INT"
    }
  ]
}

Dans cet exemple, les données de testTable sont synchronisées avec democollection. La colonne f:name (famille de colonnes et qualificateur séparés par :) correspond au champ name_s dans l'index, tandis que f:age correspond au champ age_i.

Paramètres de mappage

Paramètre	Description
`sourceNamespace`	Espace de noms de la table HBase. Laissez ce champ vide ou définissez-le sur `default` si la table ne possède pas d'espace de noms.
`sourceTable`	Nom de la table HBase, sans l'espace de noms.
`targetIndexName`	Nom de l'index Search.
`indexType`	Valeur fixe : `SOLR`.
`rowkeyFormatterType`	Méthode d'encodage de la rowkey en tant qu'ID de document d'index. Valeurs valides : `STRING`, `HEX`. Consultez Choisir un rowkeyFormatterType.
`fields`	Tableau JSON des mappages de colonnes. Séparez plusieurs entrées par des virgules. Consultez Configurer les mappages de champs.

Choisir un rowkeyFormatterType

Le paramètre rowkeyFormatterType détermine la manière dont la rowkey HBase est convertie dans le champ ID de l'index Search (toujours une chaîne de caractères).

Valeur	Cas d'utilisation	Encodage	Décodage
`STRING`	La rowkey a été écrite à l'aide de `Bytes.toBytes(String)` — par exemple, `row1`, `order0001` ou la chaîne `"12345"`	`Bytes.toString(byte[])`	`Bytes.toBytes(String)`
`HEX`	La rowkey est de type numérique, constitue une clé composite incluant des champs non textuels ou tout élément n'ayant pas été écrit à l'aide de `Bytes.toBytes(String)`	`Hex.encodeAsString(byte[])` de `org.apache.commons.codec.binary.Hex`	`Hex.decodeHex(String.toCharArray())`

Comment choisir : Tout dépend de la façon dont les octets de la rowkey ont été initialement écrits. Si Bytes.toBytes(String) a été utilisé, choisissez STRING. Pour tous les autres cas, y compris les rowkeys numériques écrites avec Bytes.toBytes(int) ou Bytes.toBytes(long), choisissez HEX.

Avertissement

Si les données n'ont pas été écrites dans la table HBase à l'aide de la fonction Bytes.toBytes(String), le type de données n'est pas considéré comme STRING. Pour importer la rowkey dans HBase, définissez ce paramètre sur HEX. Sinon, après la conversion de l'ID du document de l'index en octets, le résultat risque de différer de la rowkey d'origine.

Configurer les mappages de champs

Chaque entrée du tableau fields associe une colonne HBase à un champ d'index Search.

Paramètre	Description
`source`	Colonne HBase à mapper, au format `family:qualifier`. Par exemple, `f:name`.
`targetField`	Nom du champ de destination dans l'index Search. Les colonnes dynamiques, identifiées par un suffixe indiquant le type, sont reconnues automatiquement sans nécessiter de schéma prédéfini.
`type`	Type de données de la colonne tel qu'il est stocké dans HBase. Doit correspondre à la méthode d'écriture utilisée via `Bytes.toBytes()`. Valeurs valides (sensibles à la casse) : `INT`, `LONG`, `STRING`, `BOOLEAN`, `FLOAT`, `DOUBLE`, `SHORT`, `BIGDECIMAL`.

Colonnes dynamiques

Le service Search prend en charge les colonnes dynamiques, qui utilisent une convention de nommage par suffixe pour identifier automatiquement le type de champ. Il n'est pas nécessaire de prédéfinir chaque champ dans l'ensemble de configuration managed_schema.

Suffixes courants et types correspondants :

Suffixe	Type
`_s`	STRING
`_i`	INT

Par exemple, name_s est automatiquement reconnu comme un champ STRING et age_i comme un champ INT. Pour la liste complète des suffixes pris en charge, consultez Mettre à jour l'ensemble de configuration.

Fonctionnement des types de données HBase

HBase stocke toutes les données sous forme d'octets bruts. Le paramètre type indique au service Search comment interpréter ces octets lors de la synchronisation.

int age = 25;
byte[] ageValue = Bytes.toBytes(age);
put.addColumn(Bytes.toBytes("f"), Bytes.toBytes("age"), ageValue);

String name = "25";
byte[] nameValue = Bytes.toBytes(name);
put.addColumn(Bytes.toBytes("f"), Bytes.toBytes("name"), nameValue);

Dans cet exemple, f:age est de type INT et f:name de type STRING, bien que les deux contiennent la valeur 25. Une définition incorrecte du type amène le service Search à appeler la mauvaise méthode de décodage (par exemple, Bytes.toInt() sur une colonne de type chaîne), ce qui entraîne une corruption ou un échec de la synchronisation des données.

Le type de la colonne source et le type du champ d'index n'ont pas besoin de correspondre. Par exemple, f:age peut être stocké en tant que STRING dans HBase tandis que targetField pointe vers age_i (INT) dans l'index. Le service Search convertit automatiquement la valeur. Si la conversion de la valeur de chaîne échoue, par exemple en présence d'une valeur non numérique dans un champ INT, une erreur se produit lors de la synchronisation.

Gérer le schéma

Utilisez les commandes HBase Shell pour afficher et modifier le mappage après sa création.

Afficher le mappage actuel

Exécutez describe_external_index pour obtenir le schéma complet du mappage au format JSON :

hbase(main):005:0> describe_external_index 'testTable'

Modifier le mappage

Utilisez alter_external_index pour remplacer l'intégralité du schéma de mappage. Placez le fichier schema.json dans le répertoire de démarrage de HBase Shell ou fournissez un chemin relatif ou absolu.

hbase(main):006:0> alter_external_index 'HBase table name', 'schema.json'

Chaque appel à alter_external_index remplace le schéma complet. Pour ajouter, mettre à jour ou supprimer plusieurs colonnes simultanément, incluez toutes les colonnes dans un seul fichier JSON.

Pour supprimer tous les mappages de champs d'une table, définissez fields sur un tableau vide :

{
  "sourceNamespace": "default",
  "sourceTable": "testTable",
  "targetIndexName": "democollection",
  "indexType": "SOLR",
  "rowkeyFormatterType": "STRING",
  "fields": []
}

Ajouter des colonnes au mappage

Utilisez add_external_index_field pour ajouter des colonnes individuelles sans remplacer le schéma complet :

hbase shell> add_external_index_field 'testTable', {FAMILY => 'f', QUALIFIER => 'money', TARGETFIELD => 'money_f', TYPE => 'FLOAT'}

Remarque

add_external_index_field fonctionne uniquement sur les tables dont le schéma a déjà été modifié à l'aide de alter_external_index. Pour les modifications en bloc impliquant de nombreuses colonnes, utilisez plutôt alter_external_index : cette commande remplace l'intégralité du schéma en une seule opération.

Supprimer des colonnes du mappage

Utilisez remove_external_index pour supprimer des mappages de colonnes spécifiques :

hbase shell> remove_external_index 'testTable', 'f:name', 'f:age'

Étapes suivantes

Mettre à jour l'ensemble de configuration : configurez managed_schema pour les colonnes non dynamiques et passez en revue tous les suffixes de champs dynamiques pris en charge.