Écritures

Cette page répertorie les types de requêtes d'écriture que vous pouvez envoyer à Bigtable et précise les cas où il est opportun ou non de les utiliser. Pour en savoir plus sur l'agrégation de données dans une cellule au moment de l'écriture, consultez la section Agrégation des valeurs au moment de l'écriture.

Les API de données et les bibliothèques clientes de Bigtable vous permettent d'écrire des données dans vos tables de manière automatisée. Bigtable renvoie une réponse ou un accusé de réception pour chaque écriture.

Chaque bibliothèque cliente offre la possibilité d'envoyer les types de requêtes d'écriture suivants :

• Écritures simples
• Incréments et ajouts
• Écritures conditionnelles
• Écritures par lot

Les bibliothèques clientes Bigtable disposent d'une fonctionnalité intégrée de nouvelles tentatives d'exécution intelligentes pour les écritures simples et par lot, ce qui signifie qu'elles gèrent les indisponibilités temporaires de manière fluide. Par exemple, si votre application tente d'écrire des données et rencontre une panne ou un problème de réseau temporaires, elle procède automatiquement à une nouvelle tentative d'exécution, jusqu'à ce que l'écriture soit effective ou que l'échéance de la requête soit atteinte. Cette résilience fonctionne à la fois avec les instances à cluster unique et répliquées, et avec un routage à cluster unique ou un routage multicluster.

Pour les opérations d'écriture par lot et en flux continu, vous pouvez utiliser le connecteur Bigtable Beam. Pour en savoir plus, consultez la section Écritures par lot.

Pour en savoir plus sur les limites qui s'appliquent aux requêtes d'écriture, consultez la page Quotas et limites.

Pour obtenir des exemples de requêtes d'écriture de la bibliothèque cliente Cloud Bigtable décrits sur cette page, consultez Exemples d'écriture.

Types d'écritures et cas d'utilisation

Toutes les requêtes d'écriture incluent les composants de base suivants :

• Le nom de la table sur laquelle écrire
• Un ID de profil d'application, qui indique à Bigtable comment acheminer le trafic
• Une ou plusieurs mutations. Une mutation se compose des éléments suivants :
  • Nom de la famille de colonnes
  • Le qualificatif de colonne
  • Timestamp
  • La valeur que vous écrivez dans la table.

La valeur par défaut de l'horodatage d'une mutation correspond à la date et l'heure actuelles, mesurées en temps écoulé depuis l'epoch Unix, soit le 1er janvier 1970 à 00:00:00 UTC.

Le code temporel que vous envoyez à Bigtable doit être exprimé en microsecondes avec une précision maximale de l'ordre de la milliseconde. Un code temporel avec une précision de l'ordre de la microseconde, comme 3023483279876543, est refusé. Dans cet exemple, la valeur de code temporel acceptable est 3023483279876000.

Toutes les mutations d'une requête d'écriture ont le même code temporel, sauf si vous les remplacez. Vous pouvez définir l'horodatage de toutes les mutations d'une requête d'écriture afin qu'elles soient identiques, ou différentes les unes des autres.

Écritures simples

Vous pouvez écrire une seule ligne dans Bigtable à l'aide d'une requête MutateRow incluant le nom de la table, l'ID du profil d'application à utiliser, une clé de ligne et jusqu'à 100 000 mutations pour cette ligne. Une écriture sur une seule ligne est atomique. Utilisez ce type d'écriture lorsque vous effectuez plusieurs mutations sur une seule ligne.

Pour obtenir des exemples de code montrant comment envoyer des requêtes d'écriture simples, consultez la section Effectuer une écriture simple.

Cas pour lesquels les écritures simples ne sont pas recommandées

Les écritures simples ne sont pas le meilleur moyen d'écrire des données pour les cas d'utilisation suivants :

• Lorsque vous écrivez un lot de données qui aura des clés de ligne contiguës. Dans ce cas, il est recommandé d'utiliser des écritures par lot plutôt que des écritures simples consécutives, car un lot contigu peut être appliqué dans un seul appel de backend.

• Lorsque vous souhaitez un débit élevé (en lignes par seconde ou octets par seconde) et n'avez pas besoin d'une latence faible. Les écritures par lot seront plus rapides dans ce cas.

Mises à jour incrémentielles

Bigtable vous permet de créer des cellules avec un type de données agrégat. Les cellules agrégées sont optimisées pour les cas où vous souhaitez modifier les valeurs des cellules de tableau existantes, en agrégeant les valeurs des cellules au moment de l'écriture des données. Les types d'agrégation suivants sont disponibles:

• Somme : incrémentez un compteur ou conservez une somme cumulée.
• Minimum : envoyez un entier à une cellule, et Bigtable conserve la valeur la plus basse des deux.
• Maximum : envoyez un entier à une cellule, et Bigtable conserve la valeur la plus élevée des deux.
• HyperLogLog (HLL) : envoyez une valeur qui est ajoutée à un ensemble probabiliste de toutes les valeurs ajoutées à la cellule.

Les requêtes de mise à jour des cellules agrégées sont envoyées avec une requête MutateRow et un type de mutation AddToCell ou MergeToCell, ou l'un des types de mutation de suppression.

Ajouts

Pour ajouter des données à une valeur existante, vous pouvez utiliser une requête ReadModifyWriteRow. Cette requête inclut le nom de la table, l'ID du profil d'application à utiliser, une clé de ligne et un ensemble de règles à utiliser lors de l'écriture des données. Chaque règle comprend le nom de la famille de colonnes, le qualificatif de colonne, ainsi qu'une valeur d'ajout ou un montant d'incrément.

Les règles sont appliquées dans l'ordre. Par exemple, si votre requête inclut une requête d'ajout de la valeur d'une colonne contenant la valeur some avec la chaîne thing, et qu'une règle ultérieure comprise dans la même requête ajoute cette même colonne avec body, la valeur est modifiée deux fois dans une seule écriture atomique, et la valeur résultante est somethingbody. La règle ultérieure ne remplace pas la règle précédente.

Vous pouvez également incrémenter un entier à l'aide d'un appel ReadModifyWriteRow, mais nous vous recommandons d'utiliser des cellules agrégées et AddToCell ou MergeToCell à la place. Une valeur ne peut être incrémentée à l'aide de ReadModifyWrite que si elle est codée sous la forme d'un entier signé en mode big-endian de 64 bits. Bigtable procède à l'incrémentation d'une valeur vide, ou qui n'existe pas, comme si la valeur était zéro.

Les requêtes ReadModifyWriteRow sont atomiques. Si elles échouent pour une raison quelconque, elles ne peuvent pas faire l'objet de nouvelles tentatives d'exécution.

Quand ne pas utiliser ReadModifyWriteRow ?

N'envoyez pas de requêtes ReadModifyWriteRow dans les situations suivantes:

• Votre cas d'utilisation peut être géré en envoyant une requête MutateRow avec une mutation AddToCell. Pour en savoir plus, consultez la section Agrégation des valeurs au moment de l'écriture.

• Lorsque vous utilisez un profil d'application comportant un routage multicluster.

• Lorsque vous utilisez plusieurs profils d'application comportant un seul cluster et que vous envoyez des écritures susceptibles d'entrer en conflit avec des données écrites sur la même ligne et la même colonne dans d'autres clusters de l'instance. Avec le routage à un seul cluster, une requête d'écriture est envoyée à un seul cluster, puis répliquée.

• Lorsque vous vous basez sur la fonctionnalité de nouvelles tentatives d'exécution intelligentes fournie par les bibliothèques clientes. Une requête ReadModifyWriteRow ne peut pas être réessayée.

• Lorsque vous écrivez de grandes quantités de données et que vous avez besoin que ces écritures soient effectives rapidement. Une requête qui lit, puis modifie une ligne est plus lente qu'une requête d'écriture simple. En conséquence, ce type d'écriture ne constitue généralement pas la meilleure approche à grande échelle.

  Par exemple, si vous souhaitez compter des éléments se chiffrant en millions, comme des pages vues, vous devez MutateRow avec une mutation AddToCell pour mettre à jour vos totaux au moment de l'écriture.

Écritures conditionnelles

Si vous souhaitez rechercher une condition dans une ligne, puis, en fonction du résultat, écrire des données dans cette ligne, envoyez une requête CheckAndMutateRow. Ce type de requête comprend une clé de ligne et un filtre de ligne. Un filtre de ligne est un ensemble de règles utilisé pour vérifier la valeur des données existantes. Les mutations ne sont ensuite attribuées à des colonnes spécifiques de la ligne que lorsque certaines conditions, vérifiées par le filtre, sont remplies. Ce processus de vérification puis d’écriture s'effectue en une seule action atomique.

Une requête de filtre doit inclure au moins l'un de ces types de mutations: