Operador parse-kv
Se aplica a: ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel
Extrae información estructurada de una expresión de cadena y representa la información en formato de clave-valor.
Se admiten los siguientes modos de extracción:
- Delimeter especificado: extracción basada en delimitadores especificados que dictan cómo las claves y los pares se separan entre sí.
- Delimeter no especificado: extracción sin necesidad de especificar delimitadores. Cualquier carácter nonalphanumeric se considera un delimitador.
- Regex: extracción basada en expresiones regulares.
Sintaxis
Delimeter especificado
Claves de expresión ( as TList with pair_delimiter parse-kv ( | ) = PairDelimiter = , kv_delimiter KvDelimiter [ quote =, QuoteChars ... [, escape = EscapeChar ...]] [, greedy = true])
Delimitador no especificado
T parse-kv | Expression as ( KeysList ) ( with [quote = QuoteChars ... [, escape = EscapeChar ...]])
Regex
Claves de expresión as ( TList | parse-kv ) regex ( = with RegexPattern) )
Obtenga más información sobre las convenciones de sintaxis.
Parámetros
| Nombre | Type | Obligatorio | Descripción |
|---|---|---|---|
| Expression | string |
✔️ | Expresión de la que se van a extraer los valores de clave. |
| KeysList | string |
✔️ | Lista separada por comas de nombres de clave y sus tipos de datos de valor. El orden de las claves no tiene que coincidir con el orden en que aparecen en el texto. |
| PairDelimiter | string |
Delimitador que separa pares de valor de clave entre sí. | |
| KvDelimiter | string |
Delimitador que separa las claves de los valores. | |
| QuoteChars | string |
Literal de cadena de uno o dos caracteres que representa comillas de apertura y cierre con las que se puede incluir el nombre de clave o el valor extraído. El parámetro se puede repetir para especificar un conjunto independiente de comillas de apertura y cierre. | |
| EscapeChar | string |
Literal de cadena de un carácter que describe un carácter que se puede usar para escapar caracteres especiales en un valor entre comillas. El parámetro se puede repetir si se usan varios caracteres de escape. | |
| RegexPattern | string |
Expresión regular que contiene dos grupos de captura exactamente. El primer grupo representa el nombre de clave y el segundo grupo representa el valor de clave. |
Devoluciones
Expresión tabular de entrada original T, extendida con columnas por claves especificadas que se van a extraer.
Nota:
- Si una clave no aparece en un registro, el valor de columna correspondiente será
nullo una cadena vacía, según el tipo de columna. - Solo se extraen las claves que aparecen en el operador.
- Se extrae la primera apariencia de una clave y se omiten los valores posteriores.
- Al extraer claves y valores, se omiten los espacios en blanco iniciales y finales.
Ejemplos
Extracción con delimitadores bien definidos
En el ejemplo siguiente, las claves y los valores están separados por delimitadores bien definidos. Estos delimeters son comas y caracteres de dos puntos.
print str="ThreadId:458745723, Machine:Node001, Text: The service is up, Level: Info"
| parse-kv str as (Text: string, ThreadId:long, Machine: string) with (pair_delimiter=',', kv_delimiter=':')
| project-away str
Salida
| Texto | ThreadId | Máquina |
|---|---|---|
| El servicio está en marcha | 458745723 | Node001 |
Extracción con comillas de valor
A veces, los nombres de clave o los valores se encapsulan entre comillas, lo que permite que los propios valores contengan caracteres delimitadores. En los ejemplos siguientes se muestra cómo se usa un quote argumento para extraer estos valores.
print str='src=10.1.1.123 dst=10.1.1.124 bytes=125 failure="connection aborted" "event time"=2021-01-01T10:00:54'
| parse-kv str as (['event time']:datetime, src:string, dst:string, bytes:long, failure:string) with (pair_delimiter=' ', kv_delimiter='=', quote='"')
| project-away str
Salida
| la hora del evento | src | dst | bytes | failure |
|---|---|---|---|---|
| 2021-01-01 10:00:54.0000000 | 10.1.1.123 | 10.1.1.124 | 125 | conexión anulada |
En el ejemplo siguiente se usan comillas de apertura y cierre diferentes:
print str='src=10.1.1.123 dst=10.1.1.124 bytes=125 failure=(connection aborted) (event time)=(2021-01-01 10:00:54)'
| parse-kv str as (['event time']:datetime, src:string, dst:string, bytes:long, failure:string) with (pair_delimiter=' ', kv_delimiter='=', quote='()')
| project-away str
Salida
| la hora del evento | src | dst | bytes | failure |
|---|---|---|---|---|
| 2021-01-01 10:00:54.0000000 | 10.1.1.123 | 10.1.1.124 | 125 | conexión anulada |
Los propios valores pueden contener caracteres de comillas con escape correctamente, como se muestra en el ejemplo siguiente:
print str='src=10.1.1.123 dst=10.1.1.124 bytes=125 failure="the remote host sent \\"bye!\\"" time=2021-01-01T10:00:54'
| parse-kv str as (['time']:datetime, src:string, dst:string, bytes:long, failure:string) with (pair_delimiter=' ', kv_delimiter='=', quote='"', escape='\\')
| project-away str
Salida
| time | src | dst | bytes | failure |
|---|---|---|---|---|
| 2021-01-01 10:00:54.0000000 | 10.1.1.123 | 10.1.1.124 | 125 | el host remoto enviado "bye!" |
Extracción en modo expansivo
Hay casos en los que los valores sin comillas pueden contener delimitadores de pares. En este caso, use el greedy modo para indicar al operador que va a examinar hasta la siguiente apariencia de clave (o final de cadena) al buscar el valor final.
En los ejemplos siguientes se compara cómo funciona el operador con y sin el greedy modo especificado:
print str='name=John Doe phone=555 5555 city=New York'
| parse-kv str as (name:string, phone:string, city:string) with (pair_delimiter=' ', kv_delimiter='=')
| project-away str
Salida
| nombre | phone | city |
|---|---|---|
| John | 555 | Nuevo |
print str='name=John Doe phone=555 5555 city=New York'
| parse-kv str as (name:string, phone:string, city:string) with (pair_delimiter=' ', kv_delimiter='=', greedy=true)
| project-away str
Salida
| nombre | phone | city |
|---|---|---|
| John Doe | 555 5555 | Nueva York |
Extracción sin delimitadores bien definidos
En el ejemplo siguiente, cualquier carácter nonalphanumeric se considera un delimitador válido:
print str="2021-01-01T10:00:34 [INFO] ThreadId:458745723, Machine:Node001, Text: Started"
| parse-kv str as (Text: string, ThreadId:long, Machine: string)
| project-away str
Salida
| Texto | ThreadId | Máquina |
|---|---|---|
| Iniciado | 458745723 | Node001 |
Los valores entre comillas y escape se permiten en este modo, como se muestra en el ejemplo siguiente:
print str="2021-01-01T10:00:34 [INFO] ThreadId:458745723, Machine:Node001, Text: 'The service \\' is up'"
| parse-kv str as (Text: string, ThreadId:long, Machine: string) with (quote="'", escape='\\')
| project-away str
Salida
| Texto | ThreadId | Máquina |
|---|---|---|
| El servicio ' está en marcha | 458745723 | Node001 |
Extracción mediante regex
Cuando ningún delimitador define la estructura de texto suficientemente bien, la extracción basada en expresiones regulares puede ser útil.
print str=@'["referer url: https://hostname.com/redirect?dest=/?h=1234", "request url: https://hostname.com/?h=1234", "advertiser id: 24fefbca-cf27-4d62-a623-249c2ad30c73"]'
| parse-kv str as (['referer url']:string, ['request url']:string, ['advertiser id']: guid) with (regex=@'"([\w ]+)\s*:\s*([^"]*)"')
| project-away str
Salida
| dirección URL del referer | url de solicitud | id. de anunciante |
|---|---|---|
https://hostname.com/redirect?dest=/?h=1234 |
https://hostname.com/?h=1234 |
24fefbca-cf27-4d62-a623-249c2ad30c73 |