Dela via

Konvertera data med hjälp av dataflödeskonverteringar

  • Artikel

Viktigt!

Den här sidan innehåller instruktioner för att hantera Azure IoT Operations-komponenter med hjälp av Kubernetes-distributionsmanifest, som finns i förhandsversion. Den här funktionen har flera begränsningar och bör inte användas för produktionsarbetsbelastningar.

Juridiska villkor för Azure-funktioner i betaversion, förhandsversion eller som av någon annan anledning inte har gjorts allmänt tillgängliga ännu finns i kompletterande användningsvillkor för Microsoft Azure-förhandsversioner.

Du kan använda dataflödeskonverteringar för att transformera data i Azure IoT Operations. Konverteringselementet i ett dataflöde används för att beräkna värden för utdatafält. Du kan använda indatafält, tillgängliga åtgärder, datatyper och typkonverteringar i dataflödeskonverteringar.

Dataflödeskonverteringselementet används för att beräkna värden för utdatafält:

inputs: [
  '*.Max' // - $1
  '*.Min' // - $2
]
output: 'ColorProperties.*'
expression: '($1 + $2) / 2'

Det finns flera aspekter att förstå om konverteringar:

  • Referens till indatafält: Så här refererar du till värden från indatafält i konverteringsformeln.
  • Tillgängliga åtgärder: Åtgärder som kan användas i konverteringar. Till exempel addition, subtraktion, multiplikation och division.
  • Datatyper: Typer av data som en formel kan bearbeta och manipulera. Till exempel heltal, flyttal och sträng.
  • Typkonverteringar: Hur datatyper konverteras mellan indatafältvärdena, formelutvärderingen och utdatafälten.

Indatafält

I konverteringar kan formler fungera på statiska värden som ett tal, till exempel 25 eller parametrar som härleds från indatafält. En mappning definierar de indatafält som formeln kan komma åt. Varje fält refereras enligt dess ordning i indatalistan:

inputs: [
  '*.Max'      // - $1
  '*.Min'      // - $2
  '*.Mid.Avg'  // - $3
  '*.Mid.Mean' // - $4
]
output: 'ColorProperties.*'
expression: '($1, $2, $3, $4)'

I det här exemplet resulterar konverteringen i en matris som innehåller värdena [Max, Min, Mid.Avg, Mid.Mean]för . Kommentarerna i YAML-filen (# - $1, # - $2) är valfria, men de hjälper till att klargöra anslutningen mellan varje fältegenskap och dess roll i konverteringsformeln.

Datatyper

Olika serialiseringsformat stöder olika datatyper. JSON erbjuder till exempel några primitiva typer: sträng, tal, boolesk och null. Den innehåller även matriser av dessa primitiva typer.

När mapparen läser en indataegenskap konverteras den till en intern typ. Den här konverteringen är nödvändig för att lagra data i minnet tills de skrivs ut i ett utdatafält. Konverteringen till en intern typ sker oavsett om formaten för indata och utdatas serialisering är desamma.

Den interna representationen använder följande datatyper:

Typ Beskrivning
bool Logisk sant/falskt.
integer Lagras som 128-bitars signerat heltal.
float Lagras som 64-bitars flyttalsnummer.
string En UTF-8-sträng.
bytes Binära data, en sträng med 8-bitars osignerade värden.
datetime UTC eller lokal tid med nanosekundersupplösning.
time Tid på dagen med nanosekunders upplösning.
duration En varaktighet med nanosekundersupplösning.
array En matris med alla typer som anges tidigare.
map En vektor med (nyckel, värde) par av alla typer som anges tidigare.

Indatapostfält

När ett indatapostfält läss konverteras dess underliggande typ till en av dessa interna typvarianter. Den interna representationen är tillräckligt mångsidig för att hantera de flesta indatatyper med minimal eller ingen konvertering.

I vissa format används surrogattyper. JSON har datetime till exempel ingen typ och lagrar datetime i stället värden som strängar formaterade enligt ISO8601. När mapparen läser ett sådant fält förblir den interna representationen en sträng.

Utdatapostfält

Mapparen är utformad för att vara flexibel genom att konvertera interna typer till utdatatyper för att hantera scenarier där data kommer från ett serialiseringsformat med ett begränsat typsystem. Följande exempel visar hur konverteringar hanteras:

  • Numeriska typer: Dessa typer kan konverteras till andra representationer, även om det innebär att man förlorar precision. Till exempel kan ett 64-bitars flyttalsnummer (f64) konverteras till ett 32-bitars heltal (i32).
  • Strängar till tal: Om den inkommande posten innehåller en sträng som 123 och utdatafältet är ett 32-bitars heltal konverterar mapparen och skriver värdet som ett tal.
  • Strängar till andra typer:
    • Om utdatafältet är datetimeförsöker mapparen parsa strängen som en ISO8601 formaterad datetime.
    • Om utdatafältet är binary/bytesförsöker mapparen deserialisera strängen från en base64-kodad sträng.
  • Booleska värden:
    • Konverteras till 0/1 om utdatafältet är numeriskt.
    • Konverteras till true/false om utdatafältet är sträng.

Använda en konverteringsformel med typer

I mappningar kan en valfri formel ange hur data från indata bearbetas innan de skrivs till utdatafältet. Om ingen formel anges kopierar mapparen indatafältet till utdata med hjälp av den interna typen och konverteringsreglerna.

Om en formel anges är de datatyper som är tillgängliga för användning i formler begränsade till:

  • Heltal
  • Flyttalsnummer
  • Strängar
  • Booleska värden
  • Matriser av ovanstående typer
  • Värde saknas

Map och byte kan inte delta i formler.

Typer relaterade till tid (datetime, timeoch duration) konverteras till heltalsvärden som representerar tid i sekunder. Efter formelutvärderingen lagras resultaten i den interna representationen och konverteras inte tillbaka. Om du till exempel datetime konverterar till sekunder förblir ett heltal. Om värdet ska användas i datetime fält måste en explicit konverteringsmetod tillämpas. Ett exempel är att konvertera värdet till en ISO8601 sträng som automatiskt konverteras till datetime typen av utdatas serialiseringsformat.

Använda oregelbundna typer

Särskilda överväganden gäller för typer som matriser och värde som saknas.

Matriser

Matriser kan bearbetas med hjälp av aggregeringsfunktioner för att beräkna ett enda värde från flera element. Genom att till exempel använda indataposten:

{
  "Measurements": [2.34, 12.3, 32.4]
}

Med mappningen:

inputs: [
  'Measurements' // - $1
]
output: 'Measurement'
expression: 'min($1)'

Den här konfigurationen väljer det minsta värdet från matrisen Measurements för utdatafältet.

Matriser kan också skapas från flera enkla värden:

inputs: [
  'minimum' // - - $1
  'maximum' // - - $2
  'average' // - - $3
  'mean'    // - - $4
]
output: 'stats'
expression: '($1, $2, $3, $4)'

Den här mappningen skapar en matris som innehåller minimum, maximum, average och mean.

Värde saknas

Värdet som saknas är en särskild typ som används i scenarier, till exempel:

  • Hantera fält som saknas i indata genom att ange ett alternativt värde.
  • Villkorligt borttagning av ett fält baserat på dess närvaro.

Exempelmappning som använder ett värde som saknas:

{
  "Employment": {      
    "Position": "Analyst",
    "BaseSalary": 75000,
    "WorkingHours": "Regular"
  }
}

Indataposten innehåller fältet BaseSalary , men det kan vara valfritt. Anta att om fältet saknas måste ett värde läggas till från en kontextualiseringsdatauppsättning:

{
  "Position": "Analyst",
  "BaseSalary": 70000,
  "WorkingHours": "Regular"
}

En mappning kan kontrollera om fältet finns i indataposten. Om fältet hittas tar utdata emot det befintliga värdet. Annars tar utdata emot värdet från kontextdatauppsättningen. Till exempel:

inputs: [
  'BaseSalary' // - - - - - - - - - - - $1
  '$context(position).BaseSalary' //  - $2
]
output: 'BaseSalary'
expression: 'if($1 == (), $2, $1)'

conversion Använder funktionen if som har tre parametrar:

  • Den första parametern är ett villkor. I exemplet kontrollerar den BaseSalary om fältet i indatafältet (alias som ) är det värde som $1saknas.
  • Den andra parametern är resultatet av funktionen om villkoret i den första parametern är sant. I det här exemplet är BaseSalary det fältet för datauppsättningen för kontextualisering (alias som $2).
  • Den tredje parametern är värdet för villkoret om den första parametern är false.

Tillgängliga funktioner

Dataflöden tillhandahåller en uppsättning inbyggda funktioner som kan användas i konverteringsformler. Dessa funktioner kan användas för att utföra vanliga åtgärder som aritmetik, jämförelse och strängmanipulering. De tillgängliga funktionerna är:

Function beskrivning Exempel
min Returnera minimivärdet från en matris. min(2, 3, 1) returnerar 1, min($1) returnerar minimivärdet från matrisen $1
max Returnera det maximala värdet från en matris. max(2, 3, 1) returnerar 3, max($1) returnerar det maximala värdet från matrisen $1
if Returnera mellan värden baserat på ett villkor. if($1 > 10, 'High', 'Low') returnerar 'High' om $1 är större än 10, annars 'Low'
len Returnera teckenlängden för en sträng eller antalet element i en tuppeln. len("Azure") returnerar 5, len(1, 2, 3) returnerar 3, len($1) returnerar antalet element i matrisen $1
floor Returnera det största heltalet som är mindre än eller lika med ett tal. floor(2.9) Returnerar 2
round Returnera närmaste heltal till ett tal och avrunda halvvägs från 0,0. round(2.5) Returnerar 3
ceil Returnera det minsta heltal som är större än eller lika med ett tal. ceil(2.1) Returnerar 3
scale Skala ett värde från ett intervall till ett annat. scale($1, 0, 10, 0, 100) skalar indatavärdet från intervallet 0 till 10 till intervallet 0 till 100

Konverteringsfunktioner

Dataflöden tillhandahåller flera inbyggda konverteringsfunktioner för vanliga enhetskonverteringar som temperatur, tryck, längd, vikt och volym. Nedan följer några exempel:

Konvertering Formel Funktionsnamn
Celsius till Fahrenheit F = (C * 9/5) + 32 cToF
PSI till stapel Stapel = PSI * 0,0689476 psiToBar
Tum till cm Cm = tum * 2,54 inToCm
Fot till mätare Meter = fot * 0,3048 ftToM
Lbs till kg Kg = lbs * 0,453592 lbToKg
Gallon till liter Liter = gallons * 3.78541 galToL

Omvända konverteringar stöds också:

Konvertering Formel Funktionsnamn
Fahrenheit till Celsius C = (F - 32) * 5/9 fToC
Stapel till PSI PSI = bar / 0.0689476 barToPsi
Cm till tum Tum = cm / 2,54 cmToIn
Meter till fot Fot = mätare / 0,3048 mToFt
Kg till lbs Lbs = kg / 0,453592 kgToLb
Liter till gallon Gallon = liter / 3,78541 lToGal

Dessutom kan du definiera dina egna konverteringsfunktioner med hjälp av grundläggande matematiska formler. Systemet stöder operatorer som addition (+), subtraktion (-), multiplikation (*) och division (/). Dessa operatorer följer standardregler för prioritet, som kan justeras med parenteser för att säkerställa rätt ordning på åtgärderna. På så sätt kan du anpassa enhetskonverteringar efter specifika behov.

Tillgängliga operatorer efter prioritet

Operatör beskrivning
^ Exponentiation: $1 ^ 3

Eftersom Exponentiation har den högsta prioriteten körs den först om inte parenteser åsidosätter den här ordningen:

  • $1 * 2 ^ 3 tolkas som $1 * 8 eftersom delen 2 ^ 3 körs först, före multiplikation.
  • ($1 * 2) ^ 3 bearbetar multiplikationen före exponenteringen.
Operatör beskrivning
- Negation
! Logiskt inte

Negation och Logical not har hög prioritet, så de håller sig alltid till sin närmaste granne, förutom när exponenteringen är involverad:

  • -$1 * 2$1 först och multipliceras sedan.
  • -($1 * 2) multipliceras och negerar sedan resultatet.
Operatör beskrivning
* Multiplikation: $1 * 10
/ Division: $1/25 (Resultat är ett heltal om båda argumenten är heltal, annars flyttal)
% Modulo: $1 % 25

Multiplication, Division, och Modulo, med samma prioritet, körs från vänster till höger, såvida inte ordningen ändras av parenteser.

Operatör beskrivning
+ Tillägg för numeriska värden, sammanlänkning för strängar
- Subtraktion

Addition och Subtraction betraktas som svagare åtgärder jämfört med åtgärderna i föregående grupp:

  • $1 + 2 * 3 resulterar i $1 + 6 eftersom 2 * 3 körs först på grund av högre prioritet multiplicationför .
  • ($1 + 2) * 3 prioriterar Addition före Multiplication.
Operatör beskrivning
< Mindre än
> Större än
<= Mindre än eller lika med
>= Större än eller lika med
== Lika med
!= Inte lika med

Comparisons arbeta med numeriska värden, booleska värden och strängvärden. Eftersom de har lägre prioritet än aritmetiska operatorer behövs inga parenteser för att effektivt jämföra resultaten:

  • $1 * 2 <= $2 motsvarar ($1 * 2) <= $2.
Operatör beskrivning
|| Logiskt ELLER
&& Logiskt OCH

Logiska operatorer används för att kedja villkor:

  • $1 > 100 && $2 > 200