Conversión de datos mediante conversiones de flujo de datos
Importante
En esta página, se incluyen instrucciones para administrar componentes de Operaciones de IoT de Azure mediante manifiestos de implementación de Kubernetes, que se encuentra en versión preliminar. Esta característica se proporciona con varias limitaciones y no se debe usar para cargas de trabajo de producción.
Consulte Términos de uso complementarios para las versiones preliminares de Microsoft Azure para conocer los términos legales que se aplican a las características de Azure que se encuentran en la versión beta, en versión preliminar o que todavía no se han publicado para que estén disponibles con carácter general.
Puede usar conversiones de flujo de datos para transformar datos en Operaciones de IoT de Azure. El elemento conversión de un flujo de datos se usa para calcular los valores de los campos de salida. Puede usar campos de entrada, operaciones disponibles, tipos de datos y conversiones de tipos en las conversiones de flujo de datos.
El elemento conversión del flujo de datos se usa para calcular valores para los campos de salida:
inputs: [
'*.Max' // - $1
'*.Min' // - $2
]
output: 'ColorProperties.*'
expression: '($1 + $2) / 2'
Hay varios aspectos que se deben comprender sobre las conversiones:
- Referencia a campos de entrada: cómo hacer referencia a valores de los campos de entrada en la fórmula de conversión.
- Operaciones disponibles: operaciones que se pueden usar en las conversiones. Por ejemplo, las de suma, resta, multiplicación y división.
- Tipos de datos: tipos de datos que una fórmula puede procesar y manipular. Por ejemplo, entero, punto flotante y cadena.
- Conversiones de tipos: cómo se convierten los tipos de datos entre los valores del campo de entrada, la evaluación de fórmulas y los campos de salida.
Campos de entrada
En las conversiones, las fórmulas pueden funcionar con valores estáticos como un número como 25 o con parámetros derivados de campos de entrada. Una asignación define estos campos de entrada a los que puede acceder la fórmula. Se hace referencia a cada campo según su orden en la lista de entrada:
inputs: [
'*.Max' // - $1
'*.Min' // - $2
'*.Mid.Avg' // - $3
'*.Mid.Mean' // - $4
]
output: 'ColorProperties.*'
expression: '($1, $2, $3, $4)'
En este ejemplo, la conversión da como resultado una matriz que contiene los valores de [Max, Min, Mid.Avg, Mid.Mean]
. Los comentarios del archivo YAML (# - $1
, # - $2
) son opcionales, pero ayudan a aclarar la conexión entre cada propiedad de campo y su rol en la fórmula de conversión.
Tipos de datos
Los diferentes formatos de serialización admiten varios tipos de datos. Por ejemplo, JSON ofrece algunos tipos primitivos: cadena, número, booleano y null. También se incluyen matrices de estos tipos primitivos.
Cuando el asignador lee una propiedad de entrada, la convierte en un tipo interno. Esta conversión es necesaria para contener los datos en memoria hasta que se escriben en un campo de salida. La conversión a un tipo interno se produce independientemente de si los formatos de serialización de entrada y salida son los mismos.
La representación interna utiliza los siguientes tipos de datos:
Tipo | Descripción |
---|---|
bool |
Verdadero/falso lógico. |
integer |
Se almacena como un entero de 128 bits con signo. |
float |
Se almacena como un número de punto flotante de 64 bits. |
string |
Una cadena UTF-8. |
bytes |
Datos binarios, una cadena de valores sin signo de 8 bits. |
datetime |
Hora UTC o local con resolución en nanosegundos. |
time |
Hora del día con resolución en nanosegundos. |
duration |
Duración con resolución en nanosegundos. |
array |
Matriz de todos los tipos enumerados anteriormente. |
map |
Vector de pares (clave, valor) de cualquier tipo enumerado anteriormente. |
Campos de registro de entrada
Cuando se lee un campo de registro de entrada, su tipo subyacente se convierte en una de estas variantes de tipo interno. La representación interna es lo suficientemente versátil como para controlar la mayoría de los tipos de entrada con una conversión mínima o sin conversión.
Para algunos formatos, se usan tipos suplentes. Por ejemplo, JSON no tiene un tipo datetime
y, en su lugar, almacena los valores datetime
como cadenas con formato ISO8601. Cuando el asignador lee este campo, la representación interna permanece como una cadena.
Campos de registro de salida
El asignador está diseñado para ser flexible mediante la conversión de tipos internos en tipos de salida para dar cabida a escenarios en los que los datos proceden de un formato de serialización con un sistema de tipos limitado. En los ejemplos siguientes se muestra cómo se controlan las conversiones:
- Tipos numéricos: se pueden convertir a otras representaciones, incluso si significa perder precisión. Por ejemplo, un número de punto flotante de 64 bits (
f64
) se puede convertir en un entero de 32 bits (i32
). - Cadenas a números: si el registro entrante contiene una cadena como
123
y el campo de salida es un entero de 32 bits, el asignador convierte y escribe el valor como un número. - Cadenas a otros tipos:
- si el campo de salida es de tipo
datetime
, el asignador intenta analizar la cadena como un tipodatetime
con formato ISO8601. - Si el campo de salida es
binary/bytes
, el asignador intenta deserializar la cadena de una cadena codificada en base64.
- si el campo de salida es de tipo
- Valores booleanos:
- se convierten en
0
/1
si el campo de salida es numérico. - se convierten en
true
/false
si el campo de salida es una cadena.
- se convierten en
Uso de la fórmula de conversión con tipos
En las asignaciones, una fórmula opcional puede especificar cómo se procesan los datos de la entrada antes de escribirse en el campo de salida. Si no se especifica ninguna fórmula, el asignador copia el campo de entrada en la salida mediante el tipo interno y las reglas de conversión.
Si se especifica una fórmula, los tipos de datos disponibles para su uso en fórmulas se limitan a los siguientes:
- Enteros
- Números de punto flotante
- Cadenas
- Valores booleanos
- Matrices de los tipos anteriores
- Falta un valor
Map
y byte
no pueden participar en las fórmulas.
Los tipos relacionados con time (datetime
, time
y duration
) se convierten en valores enteros que representan el tiempo en segundos. Después de la evaluación de la fórmula, los resultados se almacenan en la representación interna y no se vuelven a convertir. Por ejemplo, un tipo datetime
convertido a segundos sigue siendo un entero. Si el valor se usará en campos datetime
, se debe aplicar un método de conversión explícito. Un ejemplo consiste en convertir el valor en una cadena de ISO8601 que se convierte automáticamente en el tipo datetime
del formato de serialización de salida.
Uso de tipos irregulares
Se aplican consideraciones especiales a tipos como las matrices y el valor faltante.
Matrices
Las matrices se pueden procesar mediante funciones de agregación para calcular un único valor a partir de varios elementos. Por ejemplo, con el registro de entrada:
{
"Measurements": [2.34, 12.3, 32.4]
}
Con la asignación:
inputs: [
'Measurements' // - $1
]
output: 'Measurement'
expression: 'min($1)'
Esta configuración selecciona el valor más pequeño de la matriz Measurements
para el campo de salida.
Las matrices también se pueden crear a partir de varios valores únicos:
inputs: [
'minimum' // - - $1
'maximum' // - - $2
'average' // - - $3
'mean' // - - $4
]
output: 'stats'
expression: '($1, $2, $3, $4)'
Esta asignación crea una matriz que contiene el valor mínimo, máximo, el promedio y la media.
Falta un valor
El valor faltante es un tipo especial que se usa en escenarios como los siguientes:
- El control de los campos que faltan en la entrada mediante el suministro de un valor alternativo.
- La eliminación condicional de un campo en función de su presencia.
Asignación de ejemplo que usa un valor faltante:
{
"Employment": {
"Position": "Analyst",
"BaseSalary": 75000,
"WorkingHours": "Regular"
}
}
El registro de entrada contiene el campo BaseSalary
, pero posiblemente sea opcional. Imagine que si falta el campo, se deba agregar un valor a partir de un conjunto de datos de contextualización:
{
"Position": "Analyst",
"BaseSalary": 70000,
"WorkingHours": "Regular"
}
Una asignación puede comprobar si el campo está presente en el registro de entrada. Si se encuentra el campo, la salida recibe ese valor existente. De lo contrario, la salida recibe el valor del conjunto de datos de contexto. Por ejemplo:
inputs: [
'BaseSalary' // - - - - - - - - - - - $1
'$context(position).BaseSalary' // - $2
]
output: 'BaseSalary'
expression: 'if($1 == (), $2, $1)'
conversion
usa la función if
, que tiene tres parámetros:
- El primer parámetro es una condición. En el ejemplo, comprueba si el campo
BaseSalary
del campo de entrada (con el alias$1
) es el valor faltante. - El segundo parámetro es el resultado de la función si la condición del primer parámetro es true. En este ejemplo, es el campo
BaseSalary
del conjunto de datos de contextualización (con el alias$2
). - El tercer parámetro es el valor de la condición si el primer parámetro es false.
Funciones disponibles
Los flujos de datos proporcionan un conjunto de funciones integradas que se pueden usar en fórmulas de conversión. Estas funciones se pueden usar para realizar operaciones comunes como la aritmética, la comparación y la manipulación de cadenas. Las funciones disponibles son:
Función | Descripción | Ejemplos |
---|---|---|
min |
Devuelve el valor mínimo de una matriz. | min(2, 3, 1) devuelve 1 , min($1) que devuelve el valor mínimo de la matriz $1 |
max |
Devuelve el valor máximo de una matriz. | max(2, 3, 1) devuelve 3 , max($1) que devuelve el valor máximo de la matriz $1 |
if |
Devuelve entre valores en función de una condición. | if($1 > 10, 'High', 'Low') devuelve 'High' si $1 es mayor que 10 ; de lo contrario, devuelve 'Low' |
len |
Devuelve la longitud de caracteres de una cadena o el número de elementos de una tupla. | len("Azure") devuelve 5 , len(1, 2, 3) devuelve 3 , len($1) que devuelve el número de elementos de la matriz $1 |
floor |
Devuelve el entero más grande menor o igual que un número. | floor(2.9) devuelve 2 . |
round |
Devuelve el entero más cercano a un número, redondeando los casos a la mitad de 0,0. | round(2.5) devuelve 3 . |
ceil |
Devuelve el entero más pequeño mayor o igual que un número. | ceil(2.1) devuelve 3 . |
scale |
Escale un valor de un intervalo a otro. | scale($1, 0, 10, 0, 100) escala el valor de entrada del intervalo de 0 a 10 al intervalo de 0 a 100. |
Funciones de conversión
Los flujos de datos proporcionan varias funciones de conversión integradas para conversiones de unidades comunes, como temperatura, presión, longitud, peso y volumen. Estos son algunos ejemplos:
Conversión | Fórmula | Nombre de la función |
---|---|---|
De grados centígrados a grados Fahrenheit | F = (C * 9/5) + 32 | cToF |
De PSI a Bar | Bar = PSI * 0,0689476 | psiToBar |
De pulgadas a centímetros | Cm = inch * 2.54 | inToCm |
De pies a metros | Metro = Pie * 0,3048 | ftToM |
De libras a kilogramos | Kg = libra * 0,453592 | lbToKg |
De galones a litros | Litros = galones * 3,78541 | galToL |
También se admiten conversiones inversas:
Conversión | Fórmula | Nombre de la función |
---|---|---|
De grados Fahrenheit a grados centígrados | C = (F - 32) * 5/9 | fToC |
De Bar a PSI | PSI = Bar / 0,0689476 | barToPsi |
De centímetros a pulgadas | Pulgada = cm / 2,54 | cmToIn |
De metros a pies | Pie = metro / 0,3048 | mToFt |
De kilogramos a libras | Libra = kg / 0,453592 | kgToLb |
De litros a galones | Galones = litros / 3,78541 | lToGal |
Además, puede definir sus propias funciones de conversión mediante fórmulas matemáticas básicas. El sistema admite operadores como suma (+
), resta (-
), multiplicación (*
) y división (/
). Estos operadores siguen las reglas estándar de precedencia, que se pueden ajustar mediante paréntesis para garantizar el orden correcto de las operaciones. Esto le permite personalizar las conversiones de unidades para satisfacer necesidades específicas.
Operadores disponibles por prioridad
Operator | Descripción |
---|---|
^ | Exponenciación: $1 ^ 3 |
Como Exponentiation
tiene la prioridad más alta, se ejecuta primero a menos que los paréntesis invaliden este orden:
$1 * 2 ^ 3
se interpreta como$1 * 8
porque la parte2 ^ 3
se ejecuta primero, antes de la multiplicación.($1 * 2) ^ 3
procesa la multiplicación antes de la exponenciación.
Operator | Descripción |
---|---|
- | Negación |
! | NOT lógico |
Negation
y Logical not
tienen prioridad alta, por lo que siempre se adhieren a su vecino inmediato, excepto cuando la exponenciación está implicada:
-$1 * 2
niega primero$1
y luego multiplica.-($1 * 2)
multiplica y luego niega el resultado.
Operator | Descripción |
---|---|
* | Multiplicación: $1 * 10 |
/ | División: $1 /25 (El resultado es un entero si ambos argumentos son enteros; de lo contrario, float) |
% | Módulo: $1 % 25 |
Multiplication
, Division
y Modulo
, que tienen la misma prioridad, se ejecutan de izquierda a derecha, a menos que el orden se modifique entre paréntesis.
Operator | Descripción |
---|---|
+ | Suma para los valores numéricos, concatenación para las cadenas |
- | Resta |
Addition
y Subtraction
se consideran operaciones más débiles en comparación con las del grupo anterior:
$1 + 2 * 3
da como resultado$1 + 6
porque2 * 3
se ejecuta primero, debido a la prioridad más alta demultiplication
.($1 + 2) * 3
priorizaAddition
antes queMultiplication
.
Operator | Descripción |
---|---|
< | Menor que |
> | Mayor que |
<= | Menor o igual que |
>= | Mayor o igual que |
== | Igual a |
!= | No igual a |
Comparisons
operan en valores numéricos, booleanos y de cadena. Como tienen menor prioridad que los operadores aritméticos, no se necesitan paréntesis para comparar los resultados de forma eficaz:
$1 * 2 <= $2
equivale a($1 * 2) <= $2
.
Operator | Descripción |
---|---|
|| | O lógico |
&& | Y lógico |
Los operadores lógicos se usan para encadenar condiciones:
$1 > 100 && $2 > 200