Partager via

Commande de table .update

  • Article

S’applique à : ✅Microsoft Fabric✅Azure Data Explorer

La .update table commande effectue des mises à jour de données dans une table spécifiée en supprimant et en ajoutant des enregistrements atomiquement.

Avertissement

Cette commande n’est pas récupérable.

Remarque

Lorsque vous exécutez la .update table commande sur une table qui est la source d’une stratégie de mise à jour, la .update table commande déclenche ces stratégies de mise à jour pour lesquelles la table en cours de modification est la source de stratégie de mise à jour.

Vous pouvez supprimer jusqu’à 5 millions d’enregistrements dans une seule commande.

autorisations

Vous devez disposer au moins des autorisations d’administrateur de table pour exécuter cette commande.

Syntaxe

En savoir plus sur les conventions de syntaxe.

.update[async] table TableName delete DeleteIdentifier append AppendIdentifier [with ( propertyName = propertyValue ] )<|
letDeleteIdentifier= DeletePredicate;
letAppendIdentifier= AppendPredicate;

Paramètres

Nom Type Requise Description
async string Si elle est spécifiée, indique que la commande s’exécute en mode asynchrone.
TableName string ✔️ Nom de la table à mettre à jour.
DeleteIdentifier string ✔️ Nom de l’identificateur utilisé pour spécifier le prédicat de suppression appliqué à la table mise à jour.
DeletePredicate string ✔️ Texte d’une requête dont les résultats sont utilisés comme données à supprimer. Le prédicat présente les mêmes limitations que le prédicat de suppression réversible.
AppendIdentifier string ✔️ Nom de l’identificateur utilisé pour spécifier le prédicat d’ajout appliqué à la table mise à jour.
AppendPredicate string ✔️ Texte d’une requête dont les résultats sont utilisés comme données à ajouter.

Important

  • Les prédicats de suppression et d’ajout ne peuvent pas utiliser d’entités distantes, de bases de données croisées et d’entités inter-clusters. Les prédicats ne peuvent pas référencer une table externe ni utiliser l’opérateur externaldata .
  • Les requêtes d’ajout et de suppression sont censées produire des résultats déterministes. Les requêtes non déterministes peuvent entraîner des résultats inattendus. Une requête est déterministe si et uniquement si elle retourne les mêmes données si elle est exécutée plusieurs fois.
  • Les requêtes peuvent être exécutées plusieurs fois dans l’exécution update . Si les résultats de la requête intermédiaire sont incohérents, la commande de mise à jour peut produire des résultats inattendus.

Propriétés prises en charge

Nom Type Description
whatif bool Si true, retourne le nombre d’enregistrements qui seront ajoutés / supprimés dans chaque partition, sans ajouter / supprimer d’enregistrements. Par défaut, il s’agit de false.
distribué bool Si true, la commande ingère à partir de tous les nœuds exécutant la requête en parallèle. La valeur par défaut est false. Consultez les conseils sur les performances.

Important

Nous vous recommandons d’exécuter en mode avant whatif d’exécuter la mise à jour pour valider les prédicats avant de supprimer ou d’ajouter des données.

Retours

Le résultat de la commande est une table où chaque enregistrement représente une étendue qui a été créée avec de nouvelles données ou qui avait des enregistrements supprimés.

Nom Type Description
Table string Table dans laquelle l’étendue a été créée ou supprimée.
Action string Créez ou supprimez en fonction de l’action effectuée dans l’étendue.
ExtentId guid Identificateur unique de l’étendue créée ou supprimée par la commande.
RowCount long Nombre de lignes créées ou supprimées dans l’étendue spécifiée par la commande.

Choisir entre .update table et matérialiser des vues

Il existe des scénarios où vous pouvez utiliser la .update table commande ou une vue matérialisée pour atteindre le même objectif dans une table. Par exemple, une vue matérialisée peut être utilisée pour conserver la dernière version de chaque enregistrement ou une mise à jour peut être utilisée pour mettre à jour les enregistrements lorsqu’une nouvelle version est disponible.

Utilisez les instructions suivantes pour déterminer la méthode à utiliser :

  • Si votre modèle de mise à jour n’est pas pris en charge par les vues matérialisées, utilisez la commande update.
  • Si la table source a un volume d’ingestion élevé, mais seulement quelques mises à jour, l’utilisation de la commande update peut être plus performante et consommer moins de cache ou de stockage que les vues matérialisées. Cela est dû au fait que les vues matérialisées doivent retraiter toutes les données ingérées, ce qui est moins efficace que d’identifier les enregistrements individuels à mettre à jour en fonction des prédicats d’ajout ou de suppression.
  • Les vues matérialisées sont une solution entièrement managée. La vue matérialisée est définie une fois et la matérialisation se produit en arrière-plan par le système. La commande de mise à jour nécessite un processus orchestré (par exemple, Azure Data Factory, Logic Apps, Power Automate et d’autres) qui exécute explicitement la commande de mise à jour chaque fois qu’il existe des mises à jour. Si les vues matérialisées fonctionnent suffisamment pour votre cas d’usage, l’utilisation de vues matérialisées nécessite moins de gestion et de maintenance.

Astuces pour les performances

  • L’ingestion de données est une opération gourmande en ressources qui peut affecter les activités simultanées sur le cluster, notamment les requêtes en cours d’exécution. Nous vous recommandons d’éviter les actions gourmandes en ressources suivantes : exécution de nombreuses .update commandes à la fois et utilisation intensive de la propriété distribuée .
  • Limitez les données d’ajout à moins de 1 Go par opération. Si nécessaire, utilisez plusieurs commandes de mise à jour.
  • Définissez l’indicateur distributed true uniquement si la quantité de données produites par la requête est volumineuse, dépasse 1 Go et ne nécessite pas de sérialisation : plusieurs nœuds peuvent ensuite produire une sortie en parallèle. N’utilisez pas cet indicateur lorsque les résultats de la requête sont petits, car il peut être inutile de générer de nombreuses petites partitions de données.

Exemples

Pour les exemples, nous allons utiliser le tableau suivant :

.set-or-replace Employees <|
  range i from 1 to 100 step 1
  | project Id=i
  | extend Code = tostring(dynamic(["Customer", "Employee"])[Id %2])
  | extend Color = tostring(dynamic(["Red", "Blue", "Gray"])[Id %3])

Cette commande crée une table avec 100 enregistrements commençant par :

id Code Couleur
1 Employee Bleu
2 Client Gris
3 Employee Rouge
4 Client Bleu
5 Employee Gris
6 Client Rouge
6 Employee Bleu

Mettre à jour une seule colonne sur une ligne

L’exemple suivant met à jour une seule colonne sur une seule ligne :

.update table Employees delete D append A with(whatif=true) <|
    let D = Employees
      | where Id==3;
    let A = Employees
      | where Id==3
      | extend Color="Orange";

Notez que whatif la valeur true est définie. Après cette requête, la table est inchangée, mais la commande retourne qu’il y aurait une extension avec une ligne supprimée et une nouvelle étendue avec une ligne.

La commande suivante effectue en fait la mise à jour :

.update table Employees delete D append A <|
    let D = Employees
      | where Id==3;
    let A = Employees
      | where Id==3
      | extend Color="Orange";

Mettre à jour une seule colonne sur plusieurs lignes

L’exemple suivant met à jour sur une seule colonne Color la valeur green sur ces lignes qui ont la valeur bleue.

.update table Employees delete D append A <|
    let D = Employees
        | where Code=="Employee"
        | where Color=="Blue";
    let A = D
      | extend Color="Green";

Ici, nous avons réutilisé l’identificateur de suppression dans la définition sur le prédicat d’ajout.

Mettre à jour plusieurs colonnes sur plusieurs lignes

L’exemple suivant met à jour plusieurs colonnes sur toutes les lignes avec gris de couleur.

.update table Employees delete D append A <|
    let D = Employees
      | where Color=="Gray";
    let A = D
      | extend Code=strcat("ex-", Code)
      | extend Color="";

Mettre à jour des lignes à l’aide d’une autre table (valeurs de référence)

Dans cet exemple, la première étape consiste à créer le tableau de mappage suivant :

.set-or-replace ColorMapping <|
  datatable(OldColor:string, NewColor:string)[
    "Red", "Pink",
    "Blue", "Purple",
    "Gray", "LightGray",
    "Orange", "Yellow",
    "Green", "AppleGreen"
  ]

Cette table de mappage est ensuite utilisée pour mettre à jour certaines couleurs dans la table d’origine :

.update table Employees delete D append A <|
  let D = Employees
    | where Code=="Customer";
  let A = D
    | lookup ColorMapping on $left.Color==$right.OldColor
    | project Id, Code, Color=NewColor

Mettre à jour des lignes avec une table de données

Parfois, les valeurs à mettre à jour sont connues sans être stockées dans une table, et l’opérateur datatable peut être utile :

.update table Employees delete D append A <|
  let A = datatable(Id:long, Code:string, Color:string)[
    1, "Customer", "Purple",
    2, "Customer", "Magenta",
    3, "Customer", "Turquoise",
  ];
  let D = Employees
      | join kind=leftsemi A on Id
      | where true;

Mettre à jour des lignes avec une table intermédiaire

Un modèle populaire consiste à atterrir les données d’abord dans une table intermédiaire avant de mettre à jour la table principale.

La première commande crée une table intermédiaire :

.set-or-replace MyStagingTable <|
    range i from 70 to 130 step 5
    | project Id=i
    | extend Code = tostring(dynamic(["Customer", "Employee"])[Id %2])
    | extend Color = tostring(dynamic(["Red", "Blue", "Gray"])[Id %3])

La commande suivante met à jour la table principale avec les données de la table intermédiaire :

.update table Employees delete D append A <|
    let A = MyStagingTable;
    let D = Employees
        | join kind=leftsemi MyStagingTable on Id
        | where true;

Certains enregistrements de la table intermédiaire n’existaient pas dans la table principale (autrement dit, avait Id>100) mais étaient toujours insérés dans la table principale (comportement upsert).

Modèle de

La première commande crée une table avec des clés composées :

.set-or-replace VersionedArticle <|
  datatable(ArticleId:string, Version:int, Detail:string)[
    "A", 1, "Early version",
    "B", 1, "News about mobiles",
    "C", 1, "Opinion article",
    "B", 2, "Revision about brand X",
    "B", 3, "Revision about brand Y",
    "C", 2, "Fact check"
  ]

La commande suivante met à jour un enregistrement spécifique à l’aide de la syntaxe développée :

.update table VersionedArticle delete D append A <|
  let D = VersionedArticle
    | where ArticleId=="B"
    | where Version==3;
  let A = VersionedArticle
    | where ArticleId=="B"
    | where Version==3
    | extend Detail = "Revision about brand Z";

Contenu connexe