Share via

.update table command (előzetes verzió)

  • Cikk

A .update table parancs adatfrissítéseket hajt végre egy adott táblában a rekordok atomi törlésével és hozzáfűzésével.

Figyelmeztetés

Ez a parancs helyreállíthatatlan.

Megjegyzés

Amikor egy frissítési .update tableszabályzat forrását képező táblán futtatja a parancsot, a parancs aktiválja azokat a .update table frissítési házirendeket, amelyeknél a módosítandó tábla a frissítési szabályzat forrása.

Egyetlen parancsban akár 5 millió rekordot is törölhet.

Engedélyek

A parancs futtatásához legalább Table Rendszergazda engedéllyel kell rendelkeznie.

Syntax

Két szintaxisbeállítás létezik: Egyszerűsített szintaxis és Kibontott szintaxis.

További információ a szintaxis konvenciókról.

Bővített szintaxis

A kibontott szintaxis rugalmasságot biztosít a sorok törlésére és a sorok hozzáfűzésére egy másik lekérdezés definiálására:

.updatetableTableNamedeleteDeleteIdentifierappendAppendIdentifier [with(propertyName=propertyValue)] <|
letDeleteIdentifier=TörlésPredikátum;
letAppendIdentifier=AppendPredicate;

A kibontott szintaxis paraméterei

Név Típus Kötelező Leírás
TableName string ✔️ A frissíteni kívánt tábla neve.
DeleteIdentifier string ✔️ A frissített táblára alkalmazott törlési predikátum megadásához használt azonosítónév.
TörlésPredikátum string ✔️ Annak a lekérdezésnek a szövege, amelynek az eredményeit a rendszer adatokként használja a törléshez. A törlési predikátumnak tartalmaznia kell legalább egy where operátort, és csak a következő operátorokat használhatja: extend, where, projectés joinlookup.
AppendIdentifier string ✔️ A frissített táblára alkalmazott hozzáfűzési predikátum megadásához használt azonosítónév.
AppendPredicate string ✔️ Annak a lekérdezésnek a szövege, amelynek az eredményeit a program adatokként használja a hozzáfűzéshez.

Fontos

  • A törlési és a hozzáfűzési predikátumok nem használhatnak távoli entitásokat, adatbázisközi és fürtök közötti entitásokat. A predikátumok nem hivatkozhatnak külső táblára, és nem használhatják az operátort externaldata .
  • A hozzáfűző és a törlési lekérdezések determinisztikus eredményeket fognak eredményezni. A nemdeterminisztikus lekérdezések váratlan eredményekhez vezethetnek. A lekérdezés determinisztikus, ha és csak akkor, ha ugyanazokat az adatokat adja vissza, ha többször is végrehajtják.
  • Előfordulhat, hogy a lekérdezések többször is végrehajthatók a végrehajtás során update . Ha a köztes lekérdezés eredményei inkonzisztensek, a frissítési parancs váratlan eredményeket eredményezhet.

Egyszerűsített szintaxis

Az egyszerűsített szintaxishoz hozzáfűző lekérdezésre és kulcsra van szükség. A kulcs egy oszlop a táblában, amely a tábla egyedi értékeit jelöli. Ez az oszlop határozza meg, hogy mely sorokat kell törölni a táblából. Az illesztés az eredeti tábla és a hozzáfűző lekérdezés között történik, hogy azonosítsa azokat a sorokat, amelyek megegyeznek az oszlop értékével.

.updatetableTableName on IDColumnName [with(propertyName=propertyValue)] <|
appendQuery

Az egyszerűsített szintaxis paraméterei

Név Típus Kötelező Leírás
TableName string ✔️ A frissíteni kívánt tábla neve.
IDColumnName string ✔️ A sorokat azonosító oszlop neve. Az oszlopnak a táblában és a appendQueryben is jelen kell lennie.
appendQuery string ✔️ Annak a lekérdezésnek vagy felügyeleti parancsnak a szövege, amelynek eredményeit a program adatokként használja a hozzáfűzéshez. A lekérdezés sémájának meg kell egyeznie a tábla sémával.

Fontos

  • A hozzáfűző lekérdezés nem használhat távoli entitásokat, adatbázisközi és fürtök közötti entitásokat, nem hivatkozhat külső táblára, és nem használhatja az operátort externaldata .
  • A hozzáfűző lekérdezésnek determinisztikus eredményeket kell eredményeznie. A nemdeterminisztikus lekérdezések váratlan eredményekhez vezethetnek. A lekérdezés determinisztikus, ha és csak akkor, ha ugyanazokat az adatokat adja vissza, ha többször is végrehajtja.
  • Előfordulhat, hogy a lekérdezések többször is végrehajthatók a végrehajtás során update . Ha a köztes lekérdezés eredményei inkonzisztensek, a frissítési parancs váratlan eredményeket eredményezhet.

Támogatott tulajdonságok

Név Típus Description
whatif logikai Ha truea függvény az összes szegmensben hozzáfűzendő/törölt rekordok számát adja vissza, rekordok hozzáfűzése/törlése nélkül. A mező alapértelmezett értéke: false.

Fontos

Javasoljuk, hogy a frissítés végrehajtása előtt futtassa whatif a módban a predikátumokat az adatok törlése vagy hozzáfűzése előtt.

Válaszok

A parancs eredménye egy olyan tábla, amelyben minden rekord egy olyan mértéket jelöl, amelyet új adatokkal hoztak létre, vagy rekordokat töröltek.

Név Típus Description
Tábla string A tábla, amelyben a mérték létre lett hozva vagy törölve lett.
Művelet string Hozzon létre vagy töröljön , attól függően, hogy milyen mértékben hajtott végre műveletet.
ExtentId guid A parancs által létrehozott vagy törölt mérték egyedi azonosítója.
RowCount long A parancs által megadott mértékben létrehozott vagy törölt sorok száma.

Választás a és a materializált nézetek között .update table

Vannak olyan forgatókönyvek, amikor a parancs vagy egy .update tablematerializált nézet használatával ugyanazt a célt érheti el egy táblában. Például egy materializált nézet használatával megtarthatja az egyes rekordok legújabb verzióját, vagy egy frissítéssel frissítheti a rekordokat, ha új verzió érhető el.

A következő irányelvek alapján döntse el, hogy melyik módszert használja:

  • Ha a materializált nézetek nem támogatják a frissítési mintát, használja a frissítési parancsot.
  • Ha a forrástábla nagy betöltési kötetet tartalmaz, de csak kevés frissítést, a frissítési parancs használata nagyobb teljesítményű lehet, és kevesebb gyorsítótárat vagy tárterületet használhat, mint a materializált nézetek. Ennek az az oka, hogy a materializált nézeteknek újra fel kell dolgozniuk az összes betöltött adatot, ami kevésbé hatékony, mint a módosítandó rekordok azonosítása a hozzáfűzési vagy törlési predikátumok alapján.
  • A materializált nézetek teljes körűen felügyelt megoldások. A materializált nézetet a rendszer egyszer definiálja , a materializálás pedig a háttérben történik. A frissítési parancshoz olyan vezénylési folyamatra van szükség (például Azure Data Factory, Logic Apps, Power Automate és mások), amely minden frissítéskor explicit módon végrehajtja a frissítési parancsot. Ha a materializált nézetek megfelelően működnek a használati esethez, a materializált nézetek használata kevesebb felügyeletet és karbantartást igényel.

Példák – Egyszerűsített szintaxis

Az alábbi példák az Egyszerűsített szintaxist használják.

Általános példa

A következő táblázat jön létre.

.set-or-replace People <|
datatable(Name:string, Address:string)[
  "Alice", "221B Baker street",
  "Bob", "1600 Pennsylvania Avenue",
  "Carl", "11 Wall Street New York"
]
Name Cím
Alice 221B Baker street
Bob 1600 Pennsylvania Avenue
Carl 11 Wall Street New York

Ezután futtassa a következő frissítési parancsot:

.update table People on Name <|
  datatable(Name:string, Address:string)[
  "Alice", "2 Macquarie Street",
  "Diana", "350 Fifth Avenue" ]

Ahol a appendQuery a következő eredményhalmazt eredményezi:

Name Cím
Alice 2 Macquarie Street
Diana 350 Ötödik sugárút

Mivel frissítettük az Nameoszlopot, az Alice sor törlődik, és a frissítés utáni tábla a következőképpen fog kinézni:

Name Cím
Alice 2 Macquarie Street
Bob 1600 Pennsylvania Avenue
Carl 11 Wall Street New York
Diana 350 Ötödik sugárút

Figyelje meg, hogy Diana nem található az eredeti táblázatban. Ez érvényes, és nem törölték a megfelelő sort.

Hasonlóképpen, ha több sor is lett volna Alice névvel az eredeti táblában, akkor az összes sor törlődött volna, és a végén lévő egyetlen Alice-sor váltotta volna fel őket.

Példatáblázat

A következő példák a következő táblázaton alapulnak:

.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])

Ez a parancs létrehoz egy táblát, amely 100 rekordot tartalmaz a következővel kezdve:

ID (Azonosító) Code Szín
1 Alkalmazott Kék
2 Ügyfél Szürke
3 Alkalmazott Piros
4 Ügyfél Kék
5 Alkalmazott Szürke
6 Ügyfél Piros
6 Alkalmazott Kék

Egyetlen oszlop frissítése egy sorban

Az alábbi példa az egyszerűsített szintaxist használja egyetlen sor egyetlen oszlopának frissítéséhez, amely megfelel a hozzáfűzési predikátumnak:

.update table Employees on Id with(whatif=true) <|
    Employees
    | where Id==3
    | extend Color="Orange"

Figyelje meg, hogy ez whatif igaz értékre van állítva. A lekérdezés után a tábla változatlan marad, de a parancs azt adja vissza, hogy egy sor törölve lett volna, egy új mérték pedig egy sorral.

A következő parancs ténylegesen végrehajtja a frissítést:

.update table Employees on Id <|
  Employees
  | where Id==3
  | extend Color="Orange"

Egyetlen oszlop frissítése több sorban

Az alábbi példa egyetlen oszlopban Color frissíti a Zöld értéket azokon a sorokon, amelyek megfelelnek a hozzáfűzési predikátumnak.

.update table Employees on Id <|
  Employees
  | where Code=="Employee"
  | where Color=="Blue"
  | extend Color="Green"

Több oszlop frissítése több sorban

Az alábbi példa a hozzáfűzési predikátumnak megfelelő összes sor több oszlopát frissíti.

.update table Employees on Id <|
  Employees
  | where Color=="Gray"
  | extend Code=strcat("ex-", Code)
  | extend Color=""

Sorok frissítése másik táblázat használatával

Ebben a példában az első lépés a következő leképezési tábla létrehozása:

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

Ez a leképezési táblázat ezután az eredeti tábla egyes színeinek frissítésére szolgál a hozzáfűzési predikátum és a megfelelő "Új szín" alapján:

.update table Employees on Id <|
  Employees
  | where Code=="Customer"
  | lookup ColorMapping on $left.Color==$right.OldColor
  | project Id, Code, Color=NewColor

Sorok frissítése előkészítési táblázattal

Népszerű minta, hogy a főtábla frissítése előtt először egy előkészítési táblába kell beszedni az adatokat.

Az első parancs létrehoz egy előkészítési táblát:

.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])

A következő parancs frissíti a főtáblát az előkészítési táblában lévő adatokkal:

.update table Employees on Id <|
  MyStagingTable

Az előkészítési tábla egyes rekordjai nem léteztek a főtáblában (vagyis volt Id>100), de továbbra is be lettek szúrva a főtáblába (upsert behavior).

Példák – Bővített szintaxis

Az alábbi példák a Kibontott szintaxist használják.

Összetett kulcs

Az egyszerűsített szintaxis feltételezi, hogy egyetlen oszlop megfeleltetheti a hozzáfűző Lekérdezés sorait a törölni kívánt sorok következtetéséhez. Egynél több oszlop használható például összetett kulcsok használatával.

Az első parancs összetett kulcsokat tartalmazó táblát hoz létre:

.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"
  ]

A következő parancs a kibontott szintaxissal frissít egy adott rekordot:

.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";

Teljes vezérlés

Az alábbi példában a program törli az alkalmazottat tartalmazó Code összes sort, és hozzáfűzi az CodeAlkalmazottésColor lila sorokat. A program több sort töröl, mint amennyit beszúr.

.update table Employees delete D append A <|
  let D = Employees
    | where Code=="Employee";
  let A = Employees
    | where Code=="Employee"
    | where Color=="Purple"
    | extend Code="Corporate"
    | extend Color="Mauve";

Ez a művelettípus csak a kibontott szintaxissal lehetséges, amely egymástól függetlenül szabályozza a törlési és hozzáfűzési műveleteket.

Kapcsolódó tartalom