Självstudie: Dirigera data med hjälp av tabelluppdateringsprinciper

Växla tjänster genom att använda listrutan Version. Läs mer om navigering.
Gäller för: ✅ Microsoft Fabric ✅ Azure Data Explorer

När dina källdata omfattar enkla och snabba transformeringar utför du dem uppströms i pipelinen med hjälp av en händelseström. Men den här metoden kanske inte fungerar bra för andra transformeringar som är komplexa eller kräver särskilda funktioner för att fungera.

I den här tutorialen lär du dig följande:

Exemplet i den här självstudien visar hur du använder uppdateringsprinciper för dataroutning för att utföra komplexa transformeringar för att berika, rensa och transformera data vid inmatningstidpunkt. En lista över andra vanliga användningsfall finns i Vanliga användningsfall för tabelluppdateringsprinciper.

Förutsättningar

  • Ett Microsoft-konto eller en Microsoft Entra-användaridentitet. En Azure-prenumeration krävs inte.

Steg 1 – Skapa tabeller och uppdatera principer

Följande steg vägleder dig genom att skapa en källtabell, transformeringsfunktioner, måltabeller och uppdateringsprinciper. Självstudien visar hur du använder tabelluppdateringsprinciper för att utföra komplexa omvandlingar och spara resultatet i en eller flera måltabeller. I exemplet används en enda källtabell med namnet Raw_Table och tre måltabeller med namnet Device_Telemetry, Device_Alarms och Error_Log.

  1. Kör följande kommando för att skapa en tabell med namnet Raw_Table.

    .create table Raw_Table (RawData: dynamic)

    Källtabellen är den plats där inmatade data sparas. Tabellen har en enda kolumn med namnet RawData av typen dynamisk. Den dynamiska typen lagrar rådata som de är, utan något schema. Mer information finns i .kommandot för att skapa tabell.

  2. Kör följande kommando för att skapa funktioner med namnet Get_Telemetry, Get_Alarms och Log_Error.

    .execute database script <|
  .create-or-alter function Get_Telemetry() {
    Raw_Table
    | where todynamic(RawData).MessageType == 'Telemetry'
    | extend
      Timestamp = unixtime_seconds_todatetime(tolong(RawData.Timestamp)),
      DeviceId = tostring(RawData.DeviceId),
      DeviceType = tostring(RawData.DeviceType),
      SensorName = tostring(RawData.SensorName),
      SensorValue = toreal(RawData.SensorValue),
      SensorUnit = tostring(RawData.SensorUnit)
    | project-away RawData
  }
  .create-or-alter function Get_Alarms() {
    Raw_Table
    | where RawData.MessageType == 'Alarms'
    | extend
      Timestamp = unixtime_seconds_todatetime(tolong(RawData.Timestamp)),
      DeviceId = tostring(RawData.DeviceId),
      DeviceType = tostring(RawData.DeviceTpe) ,
      AlarmType = tostring(RawData.AlarmType)
    | project-away RawData
  }
  .create-or-alter function Log_Error() {
    Raw_Table
    | where RawData.MessageType !in ('Telemetry', 'Alarms')
    | extend
      TimeStamp = datetime(now),
      ErrorType = 'Unknown MessageType'
    | project TimeStamp, RawData, ErrorType
  }

    När du skapar en uppdateringsprincip kan du ange ett inline-skript för utförande. Kapsla dock in transformeringslogik i en funktion. Om du använder en funktion förbättras kodunderhållet. När nya data tas emot körs funktionen för att transformera data. Funktionen kan återanvändas i flera uppdateringsprinciper. Mer information finns i .create-funktionskommandot.

  3. Kör följande kommando för att skapa måltabellerna.

    .execute database script <|
  .create table Device_Telemetry (Timestamp: datetime, DeviceId: string, DeviceType: string, SensorName: string, SensorValue: real, SensorUnit: string)
  .set-or-append Device_Alarms <| Get_Alarms | take 0
  .set-or-append Error_Log <| Log_Error | take 0

    Måltabellen måste ha samma schema som utdata från transformeringsfunktionen. Du kan skapa måltabeller på följande sätt:

    • .create table Använd kommandot och ange schemat manuellt, vilket visas när du skapar tabellen Device_Telemetry. Den här metoden kan dock vara felbenägen och tidskrävande.
    • .set-or-append Använd kommandot om du redan har skapat en funktion för att transformera data. Den här metoden skapar en ny tabell med samma schema som funktionens utdata genom att använda take 0 för att se till att funktionen endast returnerar schemat. Mer information finns i kommandot .set-or-append.

  4. Kör följande kommando för att skapa uppdateringsprinciperna för måltabellerna.

    .execute database script <|
  .alter table Device_Telemetry policy update "[{\"IsEnabled\":true,\"Source\":\"Raw_Table\",\"Query\":\"Get_Telemetry\",\"IsTransactional\":false,\"PropagateIngestionProperties\":true,\"ManagedIdentity\":null}]"
  .alter table Device_Alarms policy update "[{\"IsEnabled\":true,\"Source\":\"Raw_Table\",\"Query\":\"Get_Alarms\",\"IsTransactional\":false,\"PropagateIngestionProperties\":true,\"ManagedIdentity\":null}]"
  .alter table Error_Log policy update "[{\"IsEnabled\":true,\"Source\":\"Raw_Table\",\"Query\":\"Log_Error\",\"IsTransactional\":false,\"PropagateIngestionProperties\":true,\"ManagedIdentity\":null}]"

    .alter table policy update Använd kommandot för att länka källtabellen, transformeringsfunktionen och måltabellen. Skapa uppdateringsprincipen i måltabellen och ange källtabellen och transformeringsfunktionen. Mer information finns i uppdateringskommandot för .alter table policy.

Steg 2 – Mata in exempeldata

Om du vill testa uppdateringsprinciperna matar du in exempeldata i källtabellen .set-or-append med hjälp av kommandot . Mer information finns i Mata in data från en fråga.

.set-or-append Raw_Table <|
  let Raw_Stream = datatable(RawData: dynamic)
    [
    dynamic({"TimeStamp": 1691757932, "DeviceId": "Sensor01", "MessageType": "Telemetry", "DeviceType": "Laminator", "SensorName": "Temperature", "SensorValue": 78.3, "SensorUnit": "Celcius"}),
    dynamic({"TimeStamp": 1691757932, "DeviceId": "Sensor01", "MessageType": "Alarms", "DeviceType": "Laminator", "AlarmType": "Temperature threshold breached"}),
    dynamic({"TimeStamp": 1691757932, "DeviceId": "Sensor01", "MessageType": "Foo", "ErrorType": "Unknown"})
  ];
  Raw_Stream

Steg 3 – Verifiera resultatet

Verifiera resultatet genom att köra en fråga för att kontrollera att data har transformerats och dirigerats till måltabellerna. I följande exempel kombinerar operatorn union källan och resultatet från måltabellerna till en enda resultatuppsättning.

Raw_Table | summarize Rows=count() by TableName = "Raw_Table"
| union (Device_Telemetry | summarize Rows=count() by TableName = "Device_Telemetry")
| union (Device_Alarms | summarize Rows=count() by TableName = "Device_Alarms")
| union (Error_Log | summarize Rows=count() by TableName = "Error_Log")
| sort by Rows desc

Resultat

Du bör se följande utdata där Raw_Table har tre rader och måltabellerna har en rad vardera.

TableName Rows
Raw_Table 3
Error_Log 1
Enhet_Larm 1
Device_Telemetry 1

Steg 4 – Rensa resurser

Kör följande kommando i din databas för att rensa upp tabellerna och funktionerna som skapades i denna handledning.

.execute database script <|
  .drop table Raw_Table
  .drop table Device_Telemetry
  .drop table Device_Alarms
  .drop table Error_Log
  .drop function Get_Telemetry
  .drop function Get_Alarms
  .drop function Log_Error

Relaterat innehåll

  • Last updated on