Partager via

Modèles de requête courants dans Azure Stream Analytics et Fabric Eventstream

Note

Fabric Eventstream est basé sur le même runtime qu’Azure Stream Analytics. Par conséquent, les concepts expliqués dans cet article s’appliquent à Azure Stream Analytics et à Fabric Eventstream.

Les requêtes dans Azure Stream Analytics sont exprimées dans un langage de requête de type SQL. Les constructions linguistiques sont documentées dans le guide de référence du langage de requête Stream Analytics.

La conception de requête peut exprimer une logique de transfert simple pour déplacer des données d’événement d’un flux d’entrée vers un magasin de données de sortie, ou effectuer une analyse temporelle et de modèles riche pour calculer des agrégats sur différentes fenêtres temporelles comme dans le guide Créer une solution IoT à l'aide de Stream Analytics. Vous pouvez joindre des données à partir de plusieurs entrées pour combiner des événements de streaming et effectuer des recherches sur des données de référence statiques pour enrichir les valeurs d’événement. Vous pouvez également écrire des données dans plusieurs sorties.

Cet article décrit les solutions à plusieurs modèles de requête courants basés sur des scénarios réels.

Formats de données pris en charge

Azure Stream Analytics prend en charge le traitement des événements dans des formats de données CSV, JSON et Avro. Les formats JSON et Avro peuvent contenir des types complexes tels que des objets imbriqués (enregistrements) ou des tableaux. Pour plus d’informations sur l’utilisation de ces types de données complexes, consultez Analyse des données JSON et AVRO.

Envoyer des données à plusieurs sorties

Plusieurs instructions SELECT peuvent être utilisées pour générer des données vers différents récepteurs de sortie. Par exemple, une instruction SELECT peut générer une alerte basée sur un seuil, tandis qu’une autre peut générer des événements vers un stockage d’objets blob.

Tenez compte de l’entrée suivante :

| Make | Time |
| --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |
| Make1 |2023-01-01T00:00:02.0000000Z |
| Make2 |2023-01-01T00:00:01.0000000Z |
| Make2 |2023-01-01T00:00:02.0000000Z |
| Make2 |2023-01-01T00:00:03.0000000Z |

Vous souhaitez également obtenir les deux sorties suivantes de la requête :

ArchiveOutput :

| Make | Time |
| --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |
| Make1 |2023-01-01T00:00:02.0000000Z |
| Make2 |2023-01-01T00:00:01.0000000Z |
| Make2 |2023-01-01T00:00:02.0000000Z |
| Make2 |2023-01-01T00:00:03.0000000Z |

AlertOutput :

| Make | Time | Count |
| --- | --- | --- |
| Make2 |2023-01-01T00:00:10.0000000Z |3 |

Interrogez avec deux instructions SELECT avec la sortie Archive et la sortie d’alerte en tant que sorties :

SELECT
	*
INTO
	ArchiveOutput
FROM
	Input TIMESTAMP BY Time

SELECT
	Make,
	System.TimeStamp() AS Time,
	COUNT(*) AS [Count]
INTO
	AlertOutput
FROM
	Input TIMESTAMP BY Time
GROUP BY
	Make,
	TumblingWindow(second, 10)
HAVING
	[Count] >= 3

La clause INTO indique au service Stream Analytics dans quelles sorties écrire les données. Le premier SELECT définit une requête directe qui reçoit les données de l’entrée et les envoie à la sortie nommée ArchiveOutput. La deuxième requête agrège et filtre les données avant d’envoyer les résultats à une sortie du système d’alerte en aval appelée AlertOutput.

La clause WITH peut être utilisée pour définir plusieurs blocs de sous-requête. Cette option offre l’avantage d’ouvrir moins de lecteurs à la source d’entrée.

Requête :

WITH ReaderQuery AS (
	SELECT
		*
	FROM
		Input TIMESTAMP BY Time
)

SELECT * INTO ArchiveOutput FROM ReaderQuery

SELECT 
	Make,
	System.TimeStamp() AS Time,
	COUNT(*) AS [Count] 
INTO AlertOutput 
FROM ReaderQuery
GROUP BY
	Make,
	TumblingWindow(second, 10)
HAVING [Count] >= 3

Pour plus d’informations, consultez la clause WITH.

Requête directe simple

Une requête directe simple peut être utilisée pour copier les données du flux d’entrée dans la sortie. Par exemple, si un flux de données contenant des informations de véhicule en temps réel doit être enregistré dans une base de données SQL pour une analyse ultérieure, une requête directe simple effectue le travail.

Tenez compte de l’entrée suivante :

| Make | Time | Weight |
| --- | --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |"1000" |
| Make1 |2023-01-01T00:00:02.0000000Z |"2000" |

Vous souhaitez que la sortie soit identique à l’entrée :

| Make | Time | Weight |
| --- | --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |"1000" |
| Make1 |2023-01-01T00:00:02.0000000Z |"2000" |

Voici la requête :

SELECT
	*
INTO Output
FROM Input

Cette requête SELECT * projette tous les champs d’un événement entrant et les envoie à la sortie. Au lieu de cela, vous pouvez projeter uniquement les champs requis dans une instruction SELECT . Dans l’exemple suivant, l’instruction SELECT projette uniquement les champs Make et Time des données d’entrée.

Tenez compte de l’entrée suivante :

| Make | Time | Weight |
| --- | --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |1000 |
| Make1 |2023-01-01T00:00:02.0000000Z |2000 |
| Make2 |2023-01-01T00:00:04.0000000Z |1500 |

Vous souhaitez que la sortie ait uniquement les champs Make and Time :

| Make | Time |
| --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |
| Make1 |2023-01-01T00:00:02.0000000Z |
| Make2 |2023-01-01T00:00:04.0000000Z |

Voici la requête qui projette uniquement les champs requis :

SELECT
	Make, Time
INTO Output
FROM Input

Correspondance de chaîne avec LIKE et NOT LIKE

LIKE et NOT LIKE peuvent être utilisés pour vérifier si un champ correspond à un certain modèle. Par exemple, vous pouvez utiliser un filtre pour renvoyer uniquement les plaques d’immatriculation qui commencent par la lettre A et se terminent par le nombre 9.

Tenez compte de l’entrée suivante :

| Make | License_plate | Time |
| --- | --- | --- |
| Make1 |ABC-123 |2023-01-01T00:00:01.0000000Z |
| Make2 |AAA-999 |2023-01-01T00:00:02.0000000Z |
| Make3 |ABC-369 |2023-01-01T00:00:03.0000000Z |

Vous souhaitez que la sortie ait les plaques d’immatriculation qui commencent par la lettre A et se terminent par le nombre 9:

| Make | License_plate | Time |
| --- | --- | --- |
| Make2 |AAA-999 |2023-01-01T00:00:02.0000000Z |
| Make3 |ABC-369 |2023-01-01T00:00:03.0000000Z |

Voici une requête qui utilise l’opérateur LIKE :

SELECT
	*
FROM
	Input TIMESTAMP BY Time
WHERE
	License_plate LIKE 'A%9'

Utilisez l’instruction LIKE pour vérifier la valeur du champ License_plate . Il doit commencer par la lettre A, puis avoir une chaîne de zéro ou plus de caractères, se terminant par le nombre 9.

Calcul sur les événements passés

La fonction LAG peut être utilisée pour examiner les événements passés dans une fenêtre de temps et les comparer à l’événement actuel. Par exemple, la marque de la voiture actuelle peut être affichée si elle est différente de la marque de la dernière voiture qui est passée par le poste de péage.

Exemple d’entrée :

| Make | Time |
| --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |
| Make2 |2023-01-01T00:00:02.0000000Z |

Exemple de sortie :

| Make | Time |
| --- | --- |
| Make2 |2023-01-01T00:00:02.0000000Z |

Exemple de requête :

SELECT
	Make,
	Time
FROM
	Input TIMESTAMP BY Time
WHERE
	LAG(Make, 1) OVER (LIMIT DURATION(minute, 1)) <> Make

Utilisez LAG pour observer un aperçu du flux d’entrée un événement en arrière, récupérer la valeur Make, la comparer à la valeur Make de l’événement actuel, et générer l’événement.

Pour plus d’informations, consultez LAG.

Retourner le dernier événement dans une fenêtre

Comme les événements sont consommés par le système en temps réel, il n’existe aucune fonction qui peut déterminer si un événement est le dernier à arriver pour cette fenêtre de temps. Pour ce faire, le flux d’entrée doit être joint à un autre où l’heure d’un événement est la durée maximale de tous les événements de cette fenêtre.

Exemple d’entrée :

| License_plate | Make | Time |
| --- | --- | --- |
| DXE 5291 |Make1 |2023-07-27T00:00:05.0000000Z |
| YZK 5704 |Make3 |2023-07-27T00:02:17.0000000Z |
| RMV 8282 |Make1 |2023-07-27T00:05:01.0000000Z |
| YHN 6970 |Make2 |2023-07-27T00:06:00.0000000Z |
| VFE 1616 |Make2 |2023-07-27T00:09:31.0000000Z |
| QYF 9358 |Make1 |2023-07-27T00:12:02.0000000Z |
| MDR 6128 |Make4 |2023-07-27T00:13:45.0000000Z |

Exemple de résultat avec des informations sur les dernières voitures dans deux fenêtres de dix minutes :

| License_plate | Make | Time |
| --- | --- | --- |
| VFE 1616 |Make2 |2023-07-27T00:09:31.0000000Z |
| MDR 6128 |Make4 |2023-07-27T00:13:45.0000000Z |

Exemple de requête :

WITH LastInWindow AS
(
	SELECT 
		MAX(Time) AS LastEventTime
	FROM 
		Input TIMESTAMP BY Time
	GROUP BY 
		TumblingWindow(minute, 10)
)

SELECT 
	Input.License_plate,
	Input.Make,
	Input.Time
FROM
	Input TIMESTAMP BY Time 
	INNER JOIN LastInWindow
	ON DATEDIFF(minute, Input, LastInWindow) BETWEEN 0 AND 10
	AND Input.Time = LastInWindow.LastEventTime

La première étape de la requête recherche l’horodatage maximal dans les fenêtres de 10 minutes, c’est-à-dire l’horodatage du dernier événement pour cette fenêtre. La deuxième étape joint les résultats de la première requête avec le flux d’origine pour rechercher l’événement qui correspond aux horodatages de la dernière fenêtre.

DATEDIFF est une fonction spécifique à la date qui compare et retourne la différence d’heure entre deux champs DateTime, pour plus d’informations, consultez les fonctions de date.

Pour plus d’informations sur la jonction de flux, consultez JOIN.

Agrégation de données au fil du temps

Pour calculer des informations sur une fenêtre de temps, vous pouvez agréger les données. Dans cet exemple, l’instruction calcule un nombre au cours des 10 dernières secondes de temps pour chaque marque spécifique d’une voiture.

Exemple d’entrée :

| Make | Time | Weight |
| --- | --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |1000 |
| Make1 |2023-01-01T00:00:02.0000000Z |2000 |
| Make2 |2023-01-01T00:00:04.0000000Z |1500 |

Exemple de sortie :

| Make | Count |
| --- | --- |
| Make1 | 2 |
| Make2 | 1 |

Requête :

SELECT
	Make,
	COUNT(*) AS Count
FROM
	Input TIMESTAMP BY Time
GROUP BY
	Make,
	TumblingWindow(second, 10)

Cette agrégation regroupe les voitures par Make et les compte toutes les 10 secondes. La sortie contient le Make et Count des voitures qui ont traversé la cabine de péage.

TumblingWindow est une fonction de fenêtrage utilisée pour regrouper les événements. Une agrégation peut être appliquée sur tous les événements groupés. Pour plus d’informations, consultez les fonctions de fenêtrage.

Pour plus d’informations sur l’agrégation, consultez les fonctions d’agrégation.

Valeurs de sortie périodiques

Lorsque des événements sont manquants ou irréguliers, une sortie d’intervalle régulier peut être générée à partir d’une entrée de données plus éparse. Par exemple, générez un événement toutes les 5 secondes qui signale le point de données le plus récemment vu.

Exemple d’entrée :

| Time | Value |
| --- | --- |
| "2014-01-01T06:01:00" |1 |
| "2014-01-01T06:01:05" |2 |
| "2014-01-01T06:01:10" |3 |
| "2014-01-01T06:01:15" |4 |
| "2014-01-01T06:01:30" |5 |
| "2014-01-01T06:01:35" |6 |

Exemple de sortie (premières 10 lignes) :

| Window_end | Last_event.Time | Last_event.Value |
| --- | --- | --- |
| 2014-01-01T14:01:00.000Z |2014-01-01T14:01:00.000Z |1 |
| 2014-01-01T14:01:05.000Z |2014-01-01T14:01:05.000Z |2 |
| 2014-01-01T14:01:10.000Z |2014-01-01T14:01:10.000Z |3 |
| 2014-01-01T14:01:15.000Z |2014-01-01T14:01:15.000Z |4 |
| 2014-01-01T14:01:20.000Z |2014-01-01T14:01:15.000Z |4 |
| 2014-01-01T14:01:25.000Z |2014-01-01T14:01:15.000Z |4 |
| 2014-01-01T14:01:30.000Z |2014-01-01T14:01:30.000Z |5 |
| 2014-01-01T14:01:35.000Z |2014-01-01T14:01:35.000Z |6 |
| 2014-01-01T14:01:40.000Z |2014-01-01T14:01:35.000Z |6 |
| 2014-01-01T14:01:45.000Z |2014-01-01T14:01:35.000Z |6 |

Exemple de requête :

SELECT
	System.Timestamp() AS Window_end,
	TopOne() OVER (ORDER BY Time DESC) AS Last_event
FROM
	Input TIMESTAMP BY Time
GROUP BY
	HOPPINGWINDOW(second, 300, 5)

Cette requête génère des événements toutes les 5 secondes et génère le dernier événement reçu précédemment. La durée HOPPINGWINDOW détermine la période que la requête remonte pour trouver l'événement le plus récent.

Pour plus d’informations, consultez la fenêtre Hopping.

Mettre en corrélation des événements dans un flux

La corrélation des événements dans le même flux peut être effectuée en examinant les événements passés à l’aide de la fonction LAG . Par exemple, une sortie peut être générée chaque fois que deux voitures consécutives du même Make passent par le stand de péage au cours des 90 dernières secondes.

Exemple d’entrée :

| Make | License_plate | Time |
| --- | --- | --- |
| Make1 |ABC-123 |2023-01-01T00:00:01.0000000Z |
| Make1 |AAA-999 |2023-01-01T00:00:02.0000000Z |
| Make2 |DEF-987 |2023-01-01T00:00:03.0000000Z |
| Make1 |GHI-345 |2023-01-01T00:00:04.0000000Z |

Exemple de sortie :

| Make | Time | Current_car_license_plate | First_car_license_plate | First_car_time |
| --- | --- | --- | --- | --- |
| Make1 |2023-01-01T00:00:02.0000000Z |AAA-999 |ABC-123 |2023-01-01T00:00:01.0000000Z |

Exemple de requête :

SELECT
	Make,
	Time,
	License_plate AS Current_car_license_plate,
	LAG(License_plate, 1) OVER (LIMIT DURATION(second, 90)) AS First_car_license_plate,
	LAG(Time, 1) OVER (LIMIT DURATION(second, 90)) AS First_car_time
FROM
	Input TIMESTAMP BY Time
WHERE
	LAG(Make, 1) OVER (LIMIT DURATION(second, 90)) = Make

La fonction LAG peut examiner le flux d'entrée un événement en arrière et récupérer la valeur Make, puis comparer celle-ci à la valeur Make de l'événement actuel. Une fois la condition remplie, les données de l’événement précédent peuvent être projetées à l’aide du LAG dans l’instruction SELECT .

Pour plus d’informations, consultez LAG.

Détecter la durée entre les événements

La durée d’un événement peut être calculée en examinant le dernier événement Start une fois qu’un événement de fin est reçu. Cette requête peut être utile pour déterminer le temps passé par un utilisateur sur une page ou une fonctionnalité.

Exemple d’entrée :

| User | Feature | Event | Time |
| --- | --- | --- | --- |
| user@location.com |RightMenu |Start |2023-01-01T00:00:01.0000000Z |
| user@location.com |RightMenu |End |2023-01-01T00:00:08.0000000Z |

Exemple de sortie :

| User | Feature | Duration |
| --- | --- | --- |
| user@location.com |RightMenu |7 |

Exemple de requête :

SELECT
	[user],
	feature,
	DATEDIFF(
		second,
		LAST(Time) OVER (PARTITION BY [user], feature LIMIT DURATION(hour, 1) WHEN Event = 'start'),
		Time) as duration
FROM input TIMESTAMP BY Time
WHERE
	Event = 'end'

La fonction LAST peut être utilisée pour récupérer le dernier événement dans une condition spécifique. Dans cet exemple, la condition est un événement de type Start, partitionnant la recherche par l’utilisateur et la fonctionnalité PARTITION BY . De cette façon, chaque utilisateur et chaque fonctionnalité sont traités indépendamment lors de la recherche de l’événement Start. LIMIT DURATION limite la recherche dans le temps à 1 heure entre les événements End et Start.

Compter des valeurs uniques

COUNT et DISTINCT peuvent être utilisés pour compter le nombre de valeurs de champ uniques qui apparaissent dans le flux dans une fenêtre de temps. Vous pouvez créer une requête pour calculer le nombre de voitures uniques qui ont traversé la cabine de péage dans une fenêtre de 2 secondes.

Exemple d’entrée :

| Make | Time |
| --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |
| Make1 |2023-01-01T00:00:02.0000000Z |
| Make2 |2023-01-01T00:00:01.0000000Z |
| Make2 |2023-01-01T00:00:02.0000000Z |
| Make2 |2023-01-01T00:00:03.0000000Z |

Exemple de sortie :

| Count_make | Time |
| --- | --- |
| 2 |2023-01-01T00:00:02.000Z |
| 1 |2023-01-01T00:00:04.000Z |

Exemple de requête :

SELECT
     COUNT(DISTINCT Make) AS Count_make,
     System.TIMESTAMP() AS Time
FROM Input TIMESTAMP BY TIME
GROUP BY 
     TumblingWindow(second, 2)

COUNT(DISTINCT Make) retourne le nombre de valeurs distinctes dans la colonne Make dans une fenêtre de temps. Pour plus d’informations, consultez la fonction d’agrégation COUNT.

Récupérer le premier événement dans une fenêtre

Vous pouvez utiliser IsFirst pour récupérer le premier événement dans une fenêtre de temps. Par exemple, en affichant les informations sur la première voiture à un intervalle de 10 minutes.

Exemple d’entrée :

| License_plate | Make | Time |
| --- | --- | --- |
| DXE 5291 |Make1 |2023-07-27T00:00:05.0000000Z |
| YZK 5704 |Make3 |2023-07-27T00:02:17.0000000Z |
| RMV 8282 |Make1 |2023-07-27T00:05:01.0000000Z |
| YHN 6970 |Make2 |2023-07-27T00:06:00.0000000Z |
| VFE 1616 |Make2 |2023-07-27T00:09:31.0000000Z |
| QYF 9358 |Make1 |2023-07-27T00:12:02.0000000Z |
| MDR 6128 |Make4 |2023-07-27T00:13:45.0000000Z |

Exemple de sortie :

| License_plate | Make | Time |
| --- | --- | --- |
| DXE 5291 |Make1 |2023-07-27T00:00:05.0000000Z |
| QYF 9358 |Make1 |2023-07-27T00:12:02.0000000Z |

Exemple de requête :

SELECT 
	License_plate,
	Make,
	Time
FROM 
	Input TIMESTAMP BY Time
WHERE 
	IsFirst(minute, 10) = 1

IsFirst peut également segmenter les données et calculer le premier événement pour chaque marque de voiture spécifique Make trouvée à chaque intervalle de 10 minutes.

Exemple de sortie :

| License_plate | Make | Time |
| --- | --- | --- |
| DXE 5291 |Make1 |2023-07-27T00:00:05.0000000Z |
| YZK 5704 |Make3 |2023-07-27T00:02:17.0000000Z |
| YHN 6970 |Make2 |2023-07-27T00:06:00.0000000Z |
| QYF 9358 |Make1 |2023-07-27T00:12:02.0000000Z |
| MDR 6128 |Make4 |2023-07-27T00:13:45.0000000Z |

Exemple de requête :

SELECT 
	License_plate,
	Make,
	Time
FROM 
	Input TIMESTAMP BY Time
WHERE 
	IsFirst(minute, 10) OVER (PARTITION BY Make) = 1

Pour plus d’informations, consultez IsFirst.

Supprimer les événements en double dans une fenêtre

Lorsque vous effectuez une opération telle que le calcul des moyennes sur les événements dans une fenêtre de temps donnée, les événements en double doivent être filtrés. Dans l’exemple suivant, le deuxième événement est un doublon du premier.

Exemple d’entrée :

| DeviceId | Time | Attribute | Value |
| --- | --- | --- | --- |
| 1 |2018-07-27T00:00:01.0000000Z |Temperature |50 |
| 1 |2018-07-27T00:00:01.0000000Z |Temperature |50 |
| 2 |2018-07-27T00:00:01.0000000Z |Temperature |40 |
| 1 |2018-07-27T00:00:05.0000000Z |Temperature |60 |
| 2 |2018-07-27T00:00:05.0000000Z |Temperature |50 |
| 1 |2018-07-27T00:00:10.0000000Z |Temperature |100 |

Exemple de sortie :

| AverageValue | DeviceId |
| --- | --- |
| 70 | 1 |
|45 | 2 |

Exemple de requête :

WITH Temp AS (
	SELECT Value, DeviceId
	FROM Input TIMESTAMP BY Time
	GROUP BY Value, DeviceId, System.Timestamp()
)
 

SELECT
	AVG(Value) AS AverageValue, DeviceId
INTO Output
FROM Temp
GROUP BY DeviceId,TumblingWindow(minute, 5)

Lorsque la première instruction s'exécute, les enregistrements dupliqués sont combinés en un seul, car les champs de la clause GROUP BY sont tous identiques. Par conséquent, il supprime les doublons.

Spécifier la logique pour différents cas/valeurs (instructions CASE)

Les instructions CASE peuvent fournir différents calculs pour différents champs, en fonction d’un critère particulier. Par exemple, affectez la voie A aux voitures de Make1 et la voie B à n’importe quelle autre marque.

Exemple d’entrée :

| Make | Time |
| --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |
| Make2 |2023-01-01T00:00:02.0000000Z |
| Make2 |2023-01-01T00:00:03.0000000Z |

Exemple de sortie :

| Make |Dispatch_to_lane | Time |
| --- | --- | --- |
| Make1 |"A" |2023-01-01T00:00:01.0000000Z |
| Make2 |"B" |2023-01-01T00:00:02.0000000Z |

Exemple de requête :

SELECT
	Make
	CASE
		WHEN Make = "Make1" THEN "A"
		ELSE "B"
	END AS Dispatch_to_lane,
	System.TimeStamp() AS Time
FROM
	Input TIMESTAMP BY Time

L’expression CASE compare une expression à un ensemble d’expressions simples pour déterminer son résultat. Dans cet exemple, les véhicules de Make1 sont assignés à la voie A tandis que les véhicules de toute autre marque seront assignés à la voie B.

Pour plus d’informations, consultez l’expression de cas.

Conversion de données

Les données peuvent être castées en temps réel à l’aide de la méthode CAST . Par exemple, le poids de voiture peut être converti de type nvarchar(max) en type bigint et être utilisé dans un calcul numérique.

Exemple d’entrée :

| Make | Time | Weight |
| --- | --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |"1000" |
| Make1 |2023-01-01T00:00:02.0000000Z |"2000" |

Exemple de sortie :

| Make | Weight |
| --- | --- |
| Make1 |3000 |

Exemple de requête :

SELECT
	Make,
	SUM(CAST(Weight AS BIGINT)) AS Weight
FROM
	Input TIMESTAMP BY Time
GROUP BY
	Make,
	TumblingWindow(second, 10)

Utilisez une instruction CAST pour spécifier son type de données. Consultez la liste des types de données pris en charge sur les types de données (Azure Stream Analytics).

Pour plus d’informations sur les fonctions de conversion de données.

Détecter la durée d’une condition

Pour les conditions qui s’étendent sur plusieurs événements, la fonction LAG peut être utilisée pour identifier la durée de cette condition. Par exemple, supposons qu’un bogue ait provoqué un poids incorrect pour toutes les voitures (supérieur à 20 000 livres anglaises), et que la durée de ce bogue doit être déterminée.

Exemple d’entrée :

| Make | Time | Weight |
| --- | --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |2000 |
| Make2 |2023-01-01T00:00:02.0000000Z |25000 |
| Make1 |2023-01-01T00:00:03.0000000Z |26000 |
| Make2 |2023-01-01T00:00:04.0000000Z |25000 |
| Make1 |2023-01-01T00:00:05.0000000Z |26000 |
| Make2 |2023-01-01T00:00:06.0000000Z |25000 |
| Make1 |2023-01-01T00:00:07.0000000Z |26000 |
| Make2 |2023-01-01T00:00:08.0000000Z |2000 |

Exemple de sortie :

| Start_fault | End_fault |
| --- | --- |
| 2023-01-01T00:00:02.000Z |2023-01-01T00:00:07.000Z |

Exemple de requête :

WITH SelectPreviousEvent AS
(
SELECT
	*,
	LAG([time]) OVER (LIMIT DURATION(hour, 24)) as previous_time,
	LAG([weight]) OVER (LIMIT DURATION(hour, 24)) as previous_weight
FROM input TIMESTAMP BY [time]
)

SELECT 
	LAG(time) OVER (LIMIT DURATION(hour, 24) WHEN previous_weight < 20000 ) [Start_fault],
	previous_time [End_fault]
FROM SelectPreviousEvent
WHERE
	[weight] < 20000
	AND previous_weight > 20000

La première instruction SELECT met en corrélation la mesure de poids actuelle avec la mesure précédente, en la projetant avec la mesure actuelle. Le second SELECT revient sur le dernier événement où le previous_weight est inférieur à 20000, où le poids actuel est inférieur à 20000 et la previous_weight de l’événement actuel a été supérieure à 20000.

Le End_fault est l’événement nonfaulty actuel où l’événement précédent a été défectueux, et le Start_fault est le dernier événement nonfaulty avant cela.

Traiter des événements avec un temps indépendant (sous-flux)

Les événements peuvent arriver en retard ou dans le désordre en raison d’un décalage d’horloge entre les producteurs d’événements, les décalages d’horloge entre les partitions ou de la latence réseau. Par exemple, l’horloge de l’appareil pour TollID 2 est de cinq secondes derrière TollID 1, et l’horloge de l’appareil pour TollID 3 est de 10 secondes derrière TollID 1. Un calcul peut se produire indépendamment pour chaque péage, en utilisant uniquement ses propres données d’horloge en tant qu’horodatage.

Exemple d’entrée :

| LicensePlate | Make | Time | TollID |
| --- | --- | --- | --- |
| DXE 5291 |Make1 |2023-07-27T00:00:01.0000000Z | 1 |
| YHN 6970 |Make2 |2023-07-27T00:00:05.0000000Z | 1 |
| QYF 9358 |Make1 |2023-07-27T00:00:01.0000000Z | 2 |
| GXF 9462 |Make3 |2023-07-27T00:00:04.0000000Z | 2 |
| VFE 1616 |Make2 |2023-07-27T00:00:10.0000000Z | 1 |
| RMV 8282 |Make1 |2023-07-27T00:00:03.0000000Z | 3 |
| MDR 6128 |Make3 |2023-07-27T00:00:11.0000000Z | 2 |
| YZK 5704 |Make4 |2023-07-27T00:00:07.0000000Z | 3 |

Exemple de sortie :

| TollID | Count |
| --- | --- |
| 1 | 2 |
| 2 | 2 |
| 1 | 1 |
| 3 | 1 |
| 2 | 1 |
| 3 | 1 |

Exemple de requête :

SELECT
      TollId,
      COUNT(*) AS Count
FROM input
      TIMESTAMP BY Time OVER TollId
GROUP BY TUMBLINGWINDOW(second, 5), TollId

La clause TIMESTAMP OVER BY examine chaque chronologie d’appareil de manière indépendante en utilisant des sous-flux. L’événement de sortie de chaque TollID est généré au fur et à mesure qu’ils sont calculés, ce qui signifie que les événements sont dans l’ordre de chaque tollID au lieu d’être réorganisé comme si tous les appareils étaient sur la même horloge.

Pour plus d’informations, consultez TIMESTAMP BY OVER.

Fenêtres de session

Une fenêtre de session est une fenêtre qui continue de s’étendre à mesure que des événements se produisent et se ferme pour le calcul si aucun événement n’est reçu après une durée spécifique ou si la fenêtre atteint sa durée maximale. Cette fenêtre est particulièrement utile lors du traitement des données d'interaction utilisateur. Une fenêtre démarre lorsqu’un utilisateur commence à interagir avec le système et se ferme lorsqu’aucun autre événement n’est observé, ce qui signifie que l’utilisateur a cessé d’interagir. Par exemple, un utilisateur interagit avec une page web où le nombre de clics est journalisé, une fenêtre de session peut être utilisée pour savoir combien de temps l’utilisateur a interagissant avec le site.

Exemple d’entrée :

| User_id | Time | URL |
| --- | --- | --- |
| 0 | 2017-01-26T00:00:00.0000000Z | "www.example.com/a.html" |
| 0 | 2017-01-26T00:00:20.0000000Z | "www.example.com/b.html" |
| 1 | 2017-01-26T00:00:55.0000000Z | "www.example.com/c.html" |
| 0 | 2017-01-26T00:01:10.0000000Z | "www.example.com/d.html" |
| 1 | 2017-01-26T00:01:15.0000000Z | "www.example.com/e.html" |

Exemple de sortie :

| User_id | StartTime | EndTime | Duration_in_seconds |
| --- | --- | --- | --- |
| 0 | 2017-01-26T00:00:00.0000000Z | 2017-01-26T00:01:10.0000000Z | 70 |
| 1 | 2017-01-26T00:00:55.0000000Z | 2017-01-26T00:01:15.0000000Z | 20 |

Exemple de requête :

SELECT
	user_id,
	MIN(time) as StartTime,
	MAX(time) as EndTime,
	DATEDIFF(second, MIN(time), MAX(time)) AS duration_in_seconds
FROM input TIMESTAMP BY time
GROUP BY
	user_id,
	SessionWindow(minute, 1, 60) OVER (PARTITION BY user_id)

Select projette les données pertinentes pour l’interaction utilisateur, ainsi que la durée de l’interaction. Regroupement des données par utilisateur et sessionWindow qui se ferme si aucune interaction ne se produit dans un délai de 1 minute, avec une taille maximale de fenêtre de 60 minutes.

Pour plus d’informations sur SessionWindow, consultez la fenêtre Session .

Fonctions définies par l’utilisateur dans JavaScript et C#

Note

Cette section ne s’applique pas à Fabric Eventstream.

Le langage de requête Azure Stream Analytics peut être étendu avec des fonctions personnalisées écrites en langage JavaScript ou C#. Les fonctions définies par l’utilisateur (UDF) sont des calculs personnalisés/complexes qui ne peuvent pas être facilement exprimés à l’aide du langage SQL . Ces fonctions définies par l’utilisateur peuvent être définies une fois et utilisées plusieurs fois dans une requête. Par exemple, une fonction UDF peut être utilisée pour convertir une valeur hexadécimale nvarchar(max) en une valeur biginte .

Exemple d’entrée :

| Device_id | HexValue |
| --- | --- |
| 1 | "B4" |
| 2 | "11B" |
| 3 | "121" |

Exemple de sortie :

| Device_id | Decimal |
| --- | --- |
| 1 | 180 |
| 2 | 283 |
| 3 | 289 |

function hex2Int(hexValue){
	return parseInt(hexValue, 16);
}

public static class MyUdfClass {
	public static long Hex2Int(string hexValue){
		return int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber);
	}
}

SELECT
	Device_id,
	udf.Hex2Int(HexValue) AS Decimal
From
	Input

La fonction définie par l'utilisateur calcule la valeur bigint de HexValue pour chaque événement consommé.

Pour plus d’informations, consultez JavaScript et C#.

Reconnaissance avancée des motifs avec MATCH_RECOGNIZE

MATCH_RECOGNIZE est un mécanisme de correspondance de modèle avancé qui peut être utilisé pour faire correspondre une séquence d’événements à un modèle d’expression régulière bien défini. Par exemple, un distributeur automatique est surveillé en temps réel pour les défaillances. Pendant son fonctionnement, si deux messages d’avertissement consécutifs apparaissent, l’administrateur doit être averti.

Entrée :

| ATM_id | Operation_id | Return_Code | Time |
| --- | --- | --- | --- |
| 1 | "Entering Pin" | "Success" | 2017-01-26T00:10:00.0000000Z |
| 2 | "Opening Money Slot" | "Success" | 2017-01-26T00:10:07.0000000Z |
| 2 | "Closing Money Slot" | "Success" | 2017-01-26T00:10:11.0000000Z |
| 1 | "Entering Withdraw Quantity" | "Success" | 2017-01-26T00:10:08.0000000Z |
| 1 | "Opening Money Slot" | "Warning" | 2017-01-26T00:10:14.0000000Z |
| 1 | "Printing Bank Balance" | "Warning" | 2017-01-26T00:10:19.0000000Z |

Sortie :

| ATM_id | First_Warning_Operation_id | Warning_Time |
| --- | --- | --- |
| 1 | "Opening Money Slot" | 2017-01-26T00:10:14.0000000Z |

SELECT *
FROM input TIMESTAMP BY time OVER ATM_id
MATCH_RECOGNIZE (
	LIMIT DURATION(minute, 1)
	PARTITION BY ATM_id
	MEASURES
		First(Warning.ATM_id) AS ATM_id,
		First(Warning.Operation_Id) AS First_Warning_Operation_id,
		First(Warning.Time) AS Warning_Time
	AFTER MATCH SKIP TO NEXT ROW
	PATTERN (Success+ Warning{2,})
	DEFINE
		Success AS Success.Return_Code = 'Success',
		Warning AS Warning.Return_Code <> 'Success'
) AS patternMatch

Cette requête correspond à au moins deux événements d’échec consécutifs et génère une alarme lorsque les conditions sont remplies. PATTERN définit l’expression régulière à utiliser pour la mise en correspondance, dans ce cas, au moins deux alertes consécutives après au moins une opération réussie. Le succès et l’avertissement sont définis à l’aide de la valeur Return_Code et lorsque la condition est remplie. Les MESURES** sont projetées avec ATM_id, la première opération d’avertissement et la première heure d’avertissement.

Pour plus d’informations, consultez MATCH_RECOGNIZE.

Géofencing et requêtes géospatiales

Azure Stream Analytics fournit des fonctions géospatiales intégrées qui peuvent être utilisées pour implémenter des scénarios tels que la gestion de flotte, le partage de courses, les voitures connectées et le suivi des ressources. Les données géospatiales peuvent être ingérées dans des formats GeoJSON ou WKT dans le cadre d’eventstream ou de données de référence. Par exemple, une entreprise spécialisée dans les machines de fabrication pour imprimer des passeports, loue leurs machines aux gouvernements et aux consulats. L’emplacement de ces machines est fortement contrôlé afin d’éviter la mauvaise mise en place et l’utilisation possible pour la contrefaçon de passeports. Chaque machine est équipée d’un traceur GPS, et ces informations sont relayées vers une tâche Azure Stream Analytics. La fabrication aimerait suivre l’emplacement de ces machines et être alertée si l’une d’elles quitte une zone autorisée, de cette façon, elle peut désactiver à distance, alerter les autorités et récupérer l’équipement.

Entrée :

| Equipment_id | Equipment_current_location | Time |
| --- | --- | --- |
| 1 | "POINT(-122.13288797982818 47.64082002051315)" | 2017-01-26T00:10:00.0000000Z |
| 1 | "POINT(-122.13307252987875 47.64081350934929)" | 2017-01-26T00:11:00.0000000Z |
| 1 | "POINT(-122.13308862313283 47.6406508603241)" | 2017-01-26T00:12:00.0000000Z |
| 1 | "POINT(-122.13341048821462 47.64043760861279)" | 2017-01-26T00:13:00.0000000Z |

Entrée de données de référence :

| Equipment_id | Equipment_lease_location |
| --- | --- |
| 1 | "POLYGON((-122.13326028450979 47.6409833866794,-122.13261655434621 47.6409833866794,-122.13261655434621 47.64061471602751,-122.13326028450979 47.64061471602751,-122.13326028450979 47.6409833866794))" |

Sortie :

| Equipment_id | Equipment_alert_location | Time |
| --- | --- | --- |
| 1 | "POINT(-122.13341048821462 47.64043760861279)" | 2017-01-26T00:13:00.0000000Z |

SELECT
	input.Equipment_id AS Equipment_id,
	input.Equipment_current_location AS Equipment_current_location,
	input.Time AS Time
FROM input TIMESTAMP BY time
JOIN
	referenceInput 
	ON input.Equipment_id = referenceInput.Equipment_id
	WHERE 
		ST_WITHIN(input.Equipment_current_location, referenceInput.Equipment_lease_location) = 1

La requête permet au fabricant de surveiller automatiquement l’emplacement des machines, d’obtenir des alertes lorsqu’une machine quitte la limite géographique autorisée. La fonction géospatiale intégrée permet aux utilisateurs d’utiliser des données GPS dans la requête sans bibliothèques tierces.

Pour plus d’informations, consultez l'article scénarios de géorepérage et d’agrégation géospatiale avec Azure Stream Analytics.

Obtenir de l’aide

Pour obtenir de l’aide supplémentaire, essayez notre page de questions Microsoft Q&A pour Azure Stream Analytics.

Étapes suivantes

  • Last updated on