Lindorm:Accéder aux tables HBase à l'aide de SQL

Syntaxe

Dans Lindorm SQL, vous pouvez ajouter des mappages aux qualificateurs dans les familles de colonnes personnalisées d'une table HBase pour faciliter les requêtes SQL.

La syntaxe pour ajouter et supprimer des mappages est la suivante :

dynamic_column_mapping_statement   := ALTER TABLE table_name MAP DYNAMIC COLUMN
                                      qualifer_definition hbase_type;
dynamic_column_unmapping_statement := ALTER TABLE table_name UNMAP DYNAMIC COLUMN
                                      qualifer_definition_list;
qualifer_definition_list           := qualifer_definition
                                      (',' qualifer_definition)*
qualifer_definition                := [ family_name ':' ] qualifier_name
hbase_type                         := HLONG | HINTEGER | HSHORT | HFLOAT |
                                      HDOUBLE | HSTRING | HBOOLEAN

Le tableau suivant décrit les types de données de mappage que hbase_type peut spécifier :

Préparation des données

L'exemple suivant utilise l'API Java HBase. Pour plus d'informations, consultez la rubrique Utiliser l'API Java ApsaraDB for HBase pour développer des applications.

// Create the HBase sample table named "dt" with column family "f1"           
try (Admin admin = connection.getAdmin()) {
            HTableDescriptor htd = new HTableDescriptor(TableName.valueOf("dt"));
            htd.addFamily(new HColumnDescriptor(Bytes.toBytes("f1")));
            admin.createTable(htd);
            }
    
// Write data
try (Table table = connection.getTable(TableName.valueOf("dt"))) {
    byte[] rowkey = Bytes.toBytes("row1");
    byte[] family = Bytes.toBytes("f1");
    Put put = new Put(rowkey);
    // Write a String value, column name "name"
    String name = "Some one";
    put.addColumn(family, Bytes.toBytes("name"), Bytes.toBytes(name));
    // Write an Int value, column name "age"
    int age = 25;
    put.addColumn(family, Bytes.toBytes("age"), Bytes.toBytes(age));
    // Write a Long value, column name "time"
    long timestamp = 1656675491000L;
    put.addColumn(family, Bytes.toBytes("time"), Bytes.toBytes(timestamp));
    // Write a Short value, column name "buycode"
    short buycode = 123;
    put.addColumn(family, Bytes.toBytes("buycode"), Bytes.toBytes(buycode));
    // Write a Float value, column name "price"
    float price = 12.3f;
    put.addColumn(family, Bytes.toBytes("price"), Bytes.toBytes(price));
    // Write a Double value, column name "price2"
    double price2 = 12.33333;
    put.addColumn(family, Bytes.toBytes("price2"), Bytes.toBytes(price2));
    // Write a Boolean value, column name "isMale"
    boolean isMale = true;
    put.addColumn(family, Bytes.toBytes("isMale"), Bytes.toBytes(isMale));

    // Write a null value. For all types, writing null is expressed as:
    //put.addColumn(family, qualifier, null);

    table.put(put);
    }

Procédure

L'exemple suivant utilise la table exemple dt pour décrire comment accéder à une table HBase à l'aide de SQL.

1. Connectez-vous au moteur de tables larges à l'aide de Lindorm-cli. Pour plus d'informations, consultez la rubrique Se connecter et utiliser le moteur de tables larges avec Lindorm-cli.

   Remarque

   Si vous utilisez SQL pour accéder à une table HBase dans ApsaraDB for HBase Enhanced Edition, construisez l'adresse obtenue dans la console au format jdbc:lindorm:table:url=http://Adresse de l'API Java obtenue dans la console. Remplacez le port 30020 par 30060.

   Par exemple, si l'adresse de la chaîne de connexion obtenue dans la console est ld-bp1ietqp4fby3****-proxy-hbaseue.hbaseue.rds.aliyuncs.com:30020, l'adresse de la chaîne de connexion convertie est jdbc:lindorm:table:url=http://ld-bp1ietqp4fby3****-proxy-hbaseue.hbaseue.rds.aliyuncs.com:30060.

2. Utilisez l'instruction ALTER TABLE pour ajouter des mappages de colonnes aux données écrites dans la table dt.

   ALTER TABLE dt MAP DYNAMIC COLUMN `ROW` HSTRING, f1:name HSTRING, f1:age HINTEGER, f1:time HLONG, f1:buycode HSHORT, f1:price HFLOAT, f1:price2 HDOUBLE, f1:isMale HBOOLEAN;

   Remarque

   • L'ajout d'un mappage de colonne spécifie le type de données de la colonne, indépendamment de l'écriture des données.

   • Le système décode la valeur d'origine à partir des octets en fonction du schéma. Par conséquent, vous devez utiliser le type de données correct lors du mappage vers Lindorm SQL.

   Dans l'exemple suivant, si vous spécifiez le type de données de la colonne f:age2 comme HINTEGER, le système appelle la méthode Bytes.toInt() et renvoie une valeur d'origine incorrecte.

   int age = 25;
   byte[] ageValue = Bytes.toBytes(age);
   put.addColumn(Bytes.toBytes("f"), Bytes.toBytes("age"), ageValue);// The data type of column f:age is INT, and it is mapped to HINTEGER in Lindorm SQL.
   String age2 = "25";
   byte[] age2Value = Bytes.toBytes(age2);
   put.addColumn(Bytes.toBytes("f"), Bytes.toBytes("age2"), age2Value);// The data type of column f:age2 is STRING, and it is mapped to HSTRING in Lindorm SQL.

3. Utilisez l'instruction DESCRIBE pour afficher les relations de mappage du schéma actuel.

   DESCRIBE dt;

   Remarque

   Pour plus d'informations sur la syntaxe DESCRIBE TABLE, consultez la rubrique DESCRIBE/SHOW/USE.

4. Interrogez les données de la table dt à l'aide d'une instruction SQL.

   SELECT * FROM dt LIMIT 1;
   SELECT * FROM dt WHERE f1:isMale=true LIMIT 1;
   SELECT * FROM dt WHERE f1:name='Some one' LIMIT 1;
   SELECT * FROM dt WHERE f1:time>1656675490000 and f1:time<1656675492000 LIMIT 1;

5. (Facultatif) Créez un index secondaire.

   Un index secondaire échange de l'espace contre du temps. Il améliore l'efficacité des requêtes pour les modèles de requête ne portant pas sur la clé primaire, mais occupe un certain espace de stockage. Pour plus d'informations sur la syntaxe et les limites d'utilisation des index secondaires, consultez les rubriques CREATE INDEX et Index secondaires.

   1. Modifiez les propriétés de la table principale dt.

      ALTER TABLE dt SET 'MUTABILITY' = 'MUTABLE_LATEST';

      Remarque

      Si des horodatages personnalisés sont utilisés, définissez la propriété de la table principale sur MUTABLE_ALL.

   2. Créez l'index secondaire :

      CREATE INDEX idx ON dt(f1:age) WITH (INDEX_COVERED_TYPE ='COVERED_DYNAMIC_COLUMNS');

   3. Facultatif : Si la version de votre moteur de tables larges est antérieure à 2.6.3 et que vous utilisez le paramètre async (création d'index asynchrone) lors de la création d'un index secondaire, générez manuellement les données historiques de la table principale dans la table d'index. Une fois la génération terminée, vous pouvez interroger les données historiques à l'aide de l'index secondaire. Si le paramètre async n'est pas utilisé lors de la création, vous pouvez ignorer cette étape.

      BUILD INDEX idx ON dt;

   4. Affichez l'index.

      SHOW INDEX FROM dt;

      Résultat :

      +---------------+----------- -+-------------+--------------+------------------+---------------+-----------------+----------------+-------------+
      | TABLE_SCHEMA  | DATA_TABLE  | INDEX_NAME  | INDEX_STATE  |  INDEX_PROGRESS  |  INDEX_TYPE   |  INDEX_COVERED  |  INDEX_COLUMN  |  INDEX_TTL  |
      +---------------+-------------+-------------+--------------+------------------+---------------+-----------------+----------------+-------------+
      | default       | dt          | idx         | ACTIVE       | 100%             | SECONDARY     |  TRUE           |  f1:age,ROW    |             |
      +---------------+-------------+-------------+--------------+------------------+---------------+-----------------+----------------+-------------+

      Remarque

      • Lorsque INDEX_STATE dans la valeur de retour est Active, la génération des données est terminée.

      • PINDEX_PROGRESS dans la valeur de retour indique la progression de la génération de l'index.

   5. Facultatif : Utilisez l'instruction EXPLAIN pour afficher le plan d'exécution et vérifier si un index secondaire est utilisé.

      EXPLAIN SELECT * FROM dt WHERE f1:age=23 LIMIT 1;

6. Facultatif : Créez un index de recherche.

   1. Créez un index de recherche.

      CREATE INDEX search_idx USING SEARCH ON dt(f1:age,f1:name);

      Remarque

      Si vous créez un index de recherche sur une table HBase à l'aide de SQL, tenez compte des limites suivantes pour chaque colonne d'index de recherche :

      • Toutes les colonnes d'index de recherche doivent être définies dans le mappage de colonnes.

      • Les types de données pris en charge sont cohérents avec les types de données pouvant être mappés. Pour plus d'informations, consultez la section Types de données de mappage.

      • Vous ne pouvez pas supprimer le mappage d'une colonne d'index de recherche. Sinon, les résultats de la requête seront incorrects.

      • Si vous utilisez des horodatages personnalisés pour écrire dans la table HBase et que vous devez créer un index de recherche, vous devez définir la propriété MUTABILITY de la table sur MUTABLE_ALL.

   2. Vérifiez si l'index a été créé avec succès.

      SHOW INDEX FROM dt;

      Résultat :

      +--------------+------------+------------+-------------+----------------+------------+---------------+----------------+-----------+-------------------+
      | TABLE_SCHEMA | DATA_TABLE | INDEX_NAME | INDEX_STATE | INDEX_PROGRESS | INDEX_TYPE | INDEX_COVERED |  INDEX_COLUMN  | INDEX_TTL | INDEX_DESCRIPTION |
      +--------------+------------+------------+-------------+----------------+------------+---------------+----------------+-----------+-------------------+
      | default      | dt         | idx        | ACTIVE      | DONE           | SECONDARY  | DYNAMIC       | f1:age,ROW     |           |                   |
      | default      | dt         | search_idx | BUILDING    | N/A            | SEARCH     | NA            | f1:age,f1:name | 0         |                   |
      +--------------+------------+------------+-------------+----------------+------------+---------------+----------------+-----------+-------------------+

7. Facultatif : Supprimez les mappages de colonnes.

   • Supprimez un mappage de colonne. Voici un exemple :

     ALTER TABLE dt UNMAP DYNAMIC COLUMN f1:isMale;

   • Supprimez plusieurs mappages de colonnes. Voici un exemple :

     ALTER TABLE dt UNMAP DYNAMIC COLUMN f1:price2, f1:price2;