Převod dat pomocí převodů toků dat

Článek
11/20/2024

Důležité

Tato stránka obsahuje pokyny ke správě komponent operací Azure IoT pomocí manifestů nasazení Kubernetes, které jsou ve verzi Preview. Tato funkce je poskytována s několika omezeními a neměla by se používat pro produkční úlohy.

Právní podmínky, které platí pro funkce Azure, které jsou ve verzi beta, verzi Preview nebo které zatím nejsou veřejně dostupné, najdete v Dodatečných podmínkách použití pro Microsoft Azure verze Preview.

Převody toku dat můžete použít k transformaci dat v operacích Azure IoT. Element převodu v toku dat se používá k výpočtu hodnot pro výstupní pole. V převodech toků dat můžete použít vstupní pole, dostupné operace, datové typy a převody typů.

Element převodu toku dat slouží k výpočtu hodnot pro výstupní pole:

Bicep
Kubernetes (Preview)

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

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

Převody je potřeba pochopit několika aspekty:

Odkaz na vstupní pole: Jak odkazovat na hodnoty ze vstupních polí ve vzorci převodu.
Dostupné operace: Operace, které je možné využít při převodech. Například sčítání, odčítání, násobení a dělení.
Datové typy: Typy dat, které může vzorec zpracovávat a manipulovat s nimi. Například celé číslo, plovoucí desetinná čárka a řetězec.
Převody typů: Způsob převodu datových typů mezi hodnotami vstupního pole, vyhodnocením vzorce a výstupními poli

Vstupní pole

Při převodech můžou vzorce pracovat se statickými hodnotami, jako je například číslo 25 nebo parametry odvozené ze vstupních polí. Mapování definuje tato vstupní pole, ke kterým má vzorec přístup. Každé pole je odkazováno podle jeho pořadí ve vstupním seznamu:

Bicep
Kubernetes (Preview)

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

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

V tomto příkladu výsledkem převodu je pole obsahující hodnoty [Max, Min, Mid.Avg, Mid.Mean]. Komentáře v souboru YAML (# - $1, # - $2) jsou volitelné, ale pomáhají objasnit propojení mezi jednotlivými vlastnostmi pole a jeho rolí ve vzorci převodu.

Datové typy

Různé formáty serializace podporují různé datové typy. Json například nabízí několik primitivních typů: řetězec, číslo, logickou hodnotu a hodnotu null. Zahrnuje také pole těchto primitivních typů.

Když mapper přečte vstupní vlastnost, převede ji na interní typ. Tento převod je nezbytný pro uchovávání dat v paměti, dokud se nezapíše do výstupního pole. Převod na interní typ probíhá bez ohledu na to, jestli jsou formáty serializace vstupu a výstupu stejné.

Interní reprezentace využívá následující datové typy:

Typ	Popis
`bool`	Logická hodnota true/false
`integer`	Uloženo jako 128bitové celé číslo se signedm.
`float`	Uloženo jako 64bitové číslo s plovoucí desetinou čárkou.
`string`	Řetězec UTF-8.
`bytes`	Binární data, řetězec 8bitové hodnoty bez znaménka.
`datetime`	UTC nebo místní čas s překladem nanosekund.
`time`	Denní doba s nanosekundovým rozlišením
`duration`	Doba trvání s nanosekundovým rozlišením.
`array`	Pole všech typů uvedených dříve.
`map`	Vektor párů (klíč, hodnota) všech typů uvedených dříve.

Pole vstupního záznamu

Při čtení vstupního pole záznamu se jeho základní typ převede na jednu z těchto variant interního typu. Interní reprezentace je univerzální pro zpracování většiny vstupních typů s minimálním nebo žádným převodem.

U některých formátů se používají náhradní typy. Json například neobsahuje datetime typ a místo toho ukládá datetime hodnoty jako řetězce formátované podle ISO8601. Když mapovač načte takové pole, zůstane interní reprezentace řetězcem.

Pole výstupního záznamu

Mapovač je navržený tak, aby byl flexibilní převodem interních typů na výstupní typy, aby vyhovoval scénářům, ve kterých data pocházejí z formátu serializace s omezeným systémem typů. Následující příklady ukazují, jak se zpracovávají převody:

Číselné typy: Tyto typy lze převést na jiné reprezentace, i když to znamená ztrátu přesnosti. Například 64bitové číslo s plovoucí desetinou čárkou (f64) lze převést na 32bitové celé číslo (i32).
Řetězce na čísla: Pokud příchozí záznam obsahuje řetězec jako 123 a výstupní pole je 32bitové celé číslo, mapovač převede a zapíše hodnotu jako číslo.
Řetězce k jiným typům:
- Pokud je datetimevýstupní pole , mapper se pokusí analyzovat řetězec jako ISO8601 naformátovaný datetime.
- Pokud je binary/bytesvýstupní pole , mapper se pokusí deserializovat řetězec z řetězce s kódováním base64.
Logické hodnoty:
- Převede se na 0/1 , pokud je výstupní pole číselné.
- Převede se na true/false pole výstupu řetězec.

Použití vzorce převodu s typy

V mapování může volitelný vzorec určit, jak se před zápisem do výstupního pole zpracovávají data ze vstupu. Pokud není zadán žádný vzorec, mapper zkopíruje vstupní pole do výstupu pomocí interního typu a pravidel převodu.

Pokud je zadaný vzorec, datové typy dostupné pro použití ve vzorcích jsou omezené na:

Celá čísla
Čísla s plovoucí desetinou čárkou
Řetězce
Logické hodnoty
Pole předchozích typů
Chybějící hodnota

Map a byte nemůže se účastnit vzorců.

Typy související s časem (datetime, timea duration) se převedou na celočíselné hodnoty, které představují čas v sekundách. Po vyhodnocení vzorce se výsledky uloží do interní reprezentace a nepřevedou se zpět. Například datetime převedeno na sekundy zůstane celé číslo. Pokud se hodnota použije v datetime polích, je nutné použít explicitní metodu převodu. Příkladem je převod hodnoty na ISO8601 řetězec, který se automaticky převede na datetime typ výstupního serializačního formátu.

Použití nepravidelných typů

Zvláštní aspekty platí pro typy, jako jsou pole a chybějící hodnota.

Pole

Pole je možné zpracovat pomocí agregačních funkcí k výpočtu jedné hodnoty z více prvků. Například pomocí vstupního záznamu:

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

S mapováním:

Bicep
Kubernetes (Preview)

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

- inputs:
  - Measurements # - $1
  output: Measurement
  expression: min($1)

Tato konfigurace vybere nejmenší hodnotu z Measurements pole pro výstupní pole.

Pole lze vytvořit také z několika jednoduchých hodnot:

Bicep
Kubernetes (Preview)

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

- inputs:
  - minimum  # - - $1
  - maximum  # - - $2
  - average  # - - $3
  - mean     # - - $4
  output: stats
  expression: ($1, $2, $3, $4)

Toto mapování vytvoří pole, které obsahuje minimum, maximum, průměr a průměr.

Chybějící hodnota

Chybějící hodnota je speciální typ používaný ve scénářích, například:

Zpracování chybějícíchpolích
Podmíněné odebrání pole na základě jeho přítomnosti

Příklad mapování, které používá chybějící hodnotu:

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

Vstupní záznam obsahuje BaseSalary pole, ale může to být volitelné. Řekněme, že pokud pole chybí, musí se hodnota přidat z kontextové datové sady:

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

Mapování může zkontrolovat, jestli je pole ve vstupním záznamu. Pokud se pole najde, výstup obdrží tuto existující hodnotu. V opačném případě výstup přijme hodnotu z kontextové datové sady. Příklad:

Bicep
Kubernetes (Preview)

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

- inputs:
  - BaseSalary  # - - - - - - - - - - $1
  - $context(position).BaseSalary # - $2
  output: BaseSalary
  expression: if($1 == (), $2, $1)

Používá conversion if funkci, která má tři parametry:

Prvním parametrem je podmínka. V příkladu zkontroluje, jestli BaseSalary pole vstupního pole (aliasu jako $1) chybí hodnota.
Druhý parametr je výsledkem funkce, pokud je podmínka v prvním parametru pravdivá. V tomto příkladu se jedná o BaseSalary pole kontextové datové sady (aliasované jako $2).
Třetí parametr je hodnota podmínky, pokud je první parametr false.

Dostupné funkce

Toky dat poskytují sadu předdefinovaných funkcí, které je možné použít ve vzorcích převodu. Tyto funkce lze použít k provádění běžných operací, jako jsou aritmetika, porovnání a manipulace s řetězci. Dostupné funkce jsou:

Function	Popis	Příklady
`min`	Vrátí minimální hodnotu z pole.	`min(2, 3, 1)min($1)` vrátí `1`minimální hodnotu z pole.`$1`
`max`	Vrátí maximální hodnotu z pole.	`max(2, 3, 1)max($1)` vrátí `3`maximální hodnotu z pole.`$1`
`if`	Vrácení mezi hodnotami na základě podmínky	`if($1 > 10, 'High', 'Low')` vrátí `'High'` , pokud `$1` je větší než `10`, jinak `'Low'`
`len`	Vrátí délku znaku řetězce nebo počet prvků v řazené kolekci členů.	`len("Azure")`vrátí `5`, `len(1, 2, 3)` vrátí `3len($1)` počet prvků v matici.`$1`
`floor`	Vrátí největší celé číslo menší nebo rovno číslu.	`floor(2.9)` návraty `2`
`round`	Vrátí nejbližší celé číslo na číslo a zaokrouhlí napůl cesty od 0,0.	`round(2.5)` návraty `3`
`ceil`	Vrátí nejmenší celé číslo větší nebo rovno číslu.	`ceil(2.1)` návraty `3`
`scale`	Škálujte hodnotu z jednoho rozsahu na jinou.	`scale($1, 0, 10, 0, 100)` škáluje vstupní hodnotu z rozsahu 0 do 10 do rozsahu 0 až 100.

Převodní funkce

Toky dat poskytují několik integrovaných převodních funkcí pro běžné převody jednotek, jako je teplota, tlak, délka, váha a objem. Několik příkladů:

Převod	Vzorec	Název funkce
Celsia až Fahrenheita	F = (C * 9/5) + 32	`cToF`
PSI na panel	Pruh = PSI * 0,0689476	`psiToBar`
Inch to cm	Cm = palce * 2,54	`inToCm`
Foot to meter	Měřič = stopa * 0,3048	`ftToM`
Lbs to kg	Kg = lbs * 0,453592	`lbToKg`
Gallony na litry	Litry = galony * 3,78541	`galToL`

Podporují se také reverzní převody:

Převod	Vzorec	Název funkce
Fahrenheita ke Celsia	C = (F - 32) * 5/9	`fToC`
Pruh na PSI	PSI = bar / 0,0689476	`barToPsi`
Cm na palce	Palce = cm / 2,54	`cmToIn`
Meter to foot	Foot = meter / 0,3048	`mToFt`
Kg do lbs	Lbs = kg / 0,453592	`kgToLb`
Litery na galony	Gallons = litry / 3,78541	`lToGal`

Kromě toho můžete definovat vlastní funkce převodu pomocí základních matematických vzorců. Systém podporuje operátory, jako jsou sčítání (), odčítání (+-), násobení (*) a dělení (/). Tyto operátory dodržují standardní pravidla priority, která je možné upravit pomocí závorek, aby se zajistilo správné pořadí operací. Díky tomu můžete přizpůsobit převody jednotek tak, aby vyhovovaly konkrétním potřebám.

Dostupné operátory podle priority

Operátor	Popis
^	Exponenciální hodnota: $1 ^ 3

Vzhledem k tomu Exponentiation , že má nejvyšší prioritu, spustí se jako první, pokud závorky nepřepíší toto pořadí:

$1 * 2 ^ 3 interpretuje se jako $1 * 8 první, protože část 2 ^ 3 se provede nejprve před násobením.
($1 * 2) ^ 3 zpracuje násobení před exponentiací.

Operátor	Popis
-	Negace
!	Logický operátor not

Negation a Logical not mají vysokou prioritu, takže se vždy přichytí k bezprostřednímu sousedu, s výjimkou případů, kdy je exponenciální:

-$1 * 2 nejprve neguje a pak se vynásobí $1 .
-($1 * 2) vynásobí výsledek a pak neguje výsledek.

Operátor	Popis
*	Násobení: $1 * 10
/	Dělení: $1 / 25 (Výsledek je celé číslo, pokud oba argumenty jsou celá čísla, jinak float)
%	Modulo: $1 % 25

Multiplication, Divisiona Modulo, mají stejnou prioritu, jsou prováděny zleva doprava, pokud pořadí nezmění závorky.

Operátor	Popis
+	Sčítání číselných hodnot, zřetězení řetězců
-	Odčítání

Addition a Subtraction jsou považovány za slabší operace v porovnání s operacemi v předchozí skupině:

$1 + 2 * 3$1 + 6 výsledkem je proto, že 2 * 3 je nejprve proveden kvůli vyšší prioritě multiplication.
($1 + 2) * 3 určuje prioritu Addition před Multiplication.

Operátor	Popis
<	Je menší než
>	Je větší než
<=	Menší než nebo rovno
>=	Větší než nebo rovno
==	Rovno
!=	Nikoli rovno

Comparisons pracuje s číselnými, logickými a řetězcovými hodnotami. Vzhledem k tomu, že mají nižší prioritu než aritmetické operátory, nejsou k porovnání výsledků potřeba žádné závorky:

$1 * 2 <= $2 je ekvivalent ($1 * 2) <= $2.

Operátor	Popis
\|\|	Logický operátor OR
&&	Logický operátor AND

Logické operátory se používají ke zřetězování podmínek:

$1 > 100 && $2 > 200

Sdílet prostřednictvím