Modelli di query comuni in Analisi di flusso di Azure e Fabric Eventstream

Annotazioni

Fabric Eventstream è basato sullo stesso runtime di Analisi di flusso di Azure. Di conseguenza, i concetti illustrati in questo articolo sono applicabili sia ad Azure Stream Analytics che a Fabric Eventstream.

Le query in Analisi di flusso di Azure sono espresse in un linguaggio di query simile a SQL. I costrutti di linguaggio sono documentati nella guida di riferimento del linguaggio di query di Analisi di flusso.

Il design delle query può esprimere una semplice logica pass-through per spostare i dati degli eventi da un flusso di input in un archivio dati di output, oppure può eseguire pattern matching avanzato e analisi temporale per calcolare le aggregazioni in varie finestre temporali, come nella guida Creare una soluzione IoT usando Stream Analytics. È possibile unire dati da più input per combinare gli eventi di streaming ed eseguire ricerche sui dati di riferimento statici per arricchire i valori dell'evento. È anche possibile scrivere dati in output multipli.

Questo articolo illustra le soluzioni a diversi modelli di query comuni basati su scenari reali.

Formati di dati supportati

Analisi di flusso di Azure supporta l'elaborazione di eventi in formati di dati CSV, JSON e Avro. I formati JSON e Avro possono contenere tipi complessi, ad esempio oggetti annidati (record) o matrici. Per altre informazioni sull'uso di questi tipi di dati complessi, vedere Analisi di dati JSON e AVRO.

Inviare dati a più output

È possibile usare più istruzioni SELECT per inviare i dati a destinazioni di output diverse. Ad esempio, un'istruzione SELECT può restituire un avviso basato su soglia, mentre un altro può restituire eventi in un archivio BLOB.

Considera il seguente input:

| 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 |

Si vogliono quindi ottenere i due output seguenti dalla query:

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 |

Eseguire query con due istruzioni SELECT con output archivio e output di avviso come output:

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 clausola INTO indica al servizio Analisi di flusso, in quale degli output scrivere i dati. La prima istruzione SELECT definisce una query pass-through che riceve i dati dall'input e li invia all'output denominato ArchiveOutput. La seconda query aggrega e filtra i dati prima di inviare i risultati a un output di sistema di avvisi downstream denominato AlertOutput.

La clausola WITH può essere usata per definire più blocchi di sottoquery. Questa opzione offre il vantaggio di aprire meno lettori all'origine di input.

Query:

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

Per altre informazioni, vedere clausola WITH.

Query pass-through semplice

È possibile usare una query pass-through semplice per copiare i dati del flusso di input nell'output. Ad esempio, se un flusso di dati contenenti informazioni sul veicolo in tempo reale deve essere salvato in un database SQL per un'analisi successiva, una semplice query pass-through esegue il processo.

Considera il seguente input:

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

Si vuole che l'output corrisponda all'input:

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

Ecco la query:

SELECT
	*
INTO Output
FROM Input

Questa query SELECT * proietta tutti i campi di un evento in ingresso e li invia all'output. È invece possibile proiettare solo i campi obbligatori in un'istruzione SELECT . Nell'esempio seguente l'istruzione SELECT proietta solo i campi Make and Time dai dati di input.

Considera l'input seguente:

| 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 |

Si vuole che l'output abbia solo i campi 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 |

Ecco la query che proietta solo i campi obbligatori:

SELECT
	Make, Time
INTO Output
FROM Input

Corrispondenza di stringhe con LIKE e NOT LIKE

LIKE e NOT LIKE possono essere usati per verificare se un campo corrisponde a un determinato modello. Ad esempio, è possibile usare un filtro per restituire solo le targhe che iniziano con la lettera A e terminano con il numero 9.

Considerare l'input seguente:

| 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 |

Si vuole che l'output abbia le targhe che iniziano con la lettera A e terminano con il numero 9:

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

Ecco una query che usa l'operatore LIKE:

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

Usare l'istruzione LIKE per controllare il valore del campo License_plate . Deve iniziare con la lettera A, quindi avere qualsiasi stringa di zero o più caratteri, terminando con il numero 9.

Calcolo degli eventi precedenti

La funzione LAG può essere usata per esaminare gli eventi passati all'interno di un intervallo di tempo e confrontarli con l'evento corrente. Ad esempio, la marca dell'auto corrente può essere visualizzata se è diversa da quella dell'ultima auto che è passata attraverso il casello.

Input di esempio:

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

Output di esempio:

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

Query di esempio:

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

Usare LAG per guardare nel flusso di input indietro di un evento, recuperare il valore Make e confrontarlo con il valore Make dell'evento corrente e produrre l'evento.

Per altre informazioni, vedere LAG.

Restituire l'ultimo evento della finestra

Poiché gli eventi vengono utilizzati dal sistema in tempo reale, non esiste alcuna funzione in grado di determinare se un evento è l'ultimo per arrivare per tale intervallo di tempo. A tale scopo, il flusso di input deve essere unito a un altro in cui l'ora di un evento è il tempo massimo per tutti gli eventi in tale finestra.

Input di esempio:

| 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 |

Uscita di esempio con informazioni sulle ultime auto in due finestre temporali di dieci minuti.

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

Query di esempio:

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

Il primo passaggio della query trova il timestamp massimo in finestre di 10 minuti, ovvero il timestamp dell'ultimo evento per tale finestra. Il secondo passaggio unisce i risultati della prima query con il flusso originale per trovare l'evento corrispondente agli indicatori di ora dell'ultima finestra.

DATEDIFF è una funzione specifica della data che confronta e restituisce la differenza di tempo tra due campi DateTime. Per altre informazioni, vedere funzioni di data.

Per ulteriori informazioni su come unire i flussi, vedere JOIN.

Aggregazione dei dati nel tempo

Per calcolare le informazioni in un intervallo di tempo, è possibile aggregare i dati. In questo esempio, l'istruzione calcola un conteggio negli ultimi 10 secondi per ogni marca specifica di auto.

Input di esempio:

| 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 |

Output di esempio:

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

Query:

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

Questa aggregazione raggruppa le auto per Make e le conta ogni 10 secondi. L'output comprende il Make e il Count delle auto che passavano attraverso il casello.

TumblingWindow è una funzione di windowing usata per raggruppare gli eventi. Un'aggregazione può essere applicata a tutti gli eventi raggruppati. Per altre informazioni, vedere Funzioni di windowing.

Per altre informazioni sull'aggregazione, vedere Funzioni di aggregazione.

Valori di output periodici

Quando gli eventi sono mancanti o irregolari, è possibile generare un output a intervalli regolari da un input di dati più sparse. Ad esempio, generare un evento ogni 5 secondi che segnala il punto dati visualizzato più di recente.

Input di esempio:

| 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 |

Output di esempio (prime 10 righe):

| 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 |

Query di esempio:

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)

Questa query genera eventi ogni 5 secondi e restituisce l'ultimo evento ricevuto in precedenza. La durata di HOPPINGWINDOW determina quanto tempo la query cerca di trovare l'evento più recente.

Per altre informazioni, vedere Finestra di salto.

Correlare gli eventi in un flusso

La correlazione degli eventi nello stesso flusso può essere eseguita esaminando gli eventi passati usando la funzione LAG . Ad esempio, un output può essere generato ogni volta che due auto consecutive dello stesso Make passano attraverso il casello negli ultimi 90 secondi.

Input di esempio:

| 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 |

Output di esempio:

| 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 |

Query di esempio:

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 funzione LAG può esaminare nuovamente il flusso di input un evento e recuperare il valore Make , confrontandolo con il valore Make dell'evento corrente. Una volta soddisfatta la condizione, i dati dell'evento precedente possono essere proiettati usando LAG nell'istruzione SELECT .

Per altre informazioni, vedere LAG.

Rilevare la durata tra gli eventi

La durata di un evento può essere calcolata esaminando l'ultimo evento Start dopo la ricezione di un evento End. Questa query può essere utile per determinare il tempo trascorso da un utente in una pagina o in una funzionalità.

Input di esempio:

| 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 |

Output di esempio:

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

Query di esempio:

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 funzione LAST può essere usata per recuperare l'ultimo evento all'interno di una condizione specifica. In questo esempio la condizione è un evento di tipo Start, partizionando la ricerca in base all'utente e alla funzionalità PARTITION BY . In questo modo, ogni utente e funzionalità vengono trattati in modo indipendente durante la ricerca dell'evento Start. LIMIT DURATION limita la ricerca indietro nel tempo a 1 ora tra gli eventi End e Start.

Conta valori univoci

COUNT e DISTINCT possono essere usati per contare il numero di valori di campo univoci visualizzati nel flusso entro un intervallo di tempo. È possibile creare una query per calcolare il numero univoco di marche di automobili che sono passate attraverso il casello in una finestra di 2 secondi.

Input di esempio:

| 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 |

Output di esempio:

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

Query di esempio:

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

COUNT(DISTINCT Make) restituisce il conteggio dei valori distinti nella colonna Make in un intervallo di tempo. Per altre informazioni, vedere Funzione di aggregazione COUNT.

Recuperare il primo evento in una finestra

È possibile usare IsFirst per recuperare il primo evento in un intervallo di tempo. Ad esempio, mostrare le informazioni della prima auto a intervalli di 10 minuti.

Input di esempio:

| 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 |

Output di esempio:

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

Query di esempio:

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

IsFirst può anche partizionare i dati e calcolare il primo evento per ogni auto specifica Make trovato ogni intervallo di 10 minuti.

Output di esempio:

| 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 |

Query di esempio:

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

Per altre informazioni, vedere IsFirst.

Rimuovere eventi duplicati in una finestra

Quando si esegue un'operazione, ad esempio il calcolo delle medie sugli eventi in un determinato intervallo di tempo, è necessario filtrare gli eventi duplicati. Nell'esempio seguente il secondo evento è un duplicato del primo.

Input di esempio:

| 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 |

Output di esempio:

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

Query di esempio:

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)

Quando viene eseguita la prima istruzione, i record duplicati vengono combinati in uno poiché i campi nella clausola GROUP BY sono tutti uguali. Pertanto, rimuove i duplicati.

Specificare la logica per casi/valori diversi (istruzioni CASE)

Le istruzioni CASE possono fornire calcoli diversi per campi diversi, in base a un criterio specifico. Ad esempio, assegnare la corsia A alle auto della marca Make1 e la corsia B a qualsiasi altra marca.

Input di esempio:

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

Output di esempio:

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

Query di esempio:

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'espressione CASE confronta un'espressione con un set di espressioni semplici per determinarne il risultato. In questo esempio, i veicoli di Make1 vengono inviati alla corsia A mentre ai veicoli di qualsiasi altro veicolo verrà assegnata la corsia B.

Per ulteriori informazioni, vedere case expression.

Conversione dei dati

È possibile eseguire il cast dei dati in tempo reale usando il metodo CAST . Ad esempio, il peso dell'auto può essere convertito dal tipo nvarchar(max) al tipo bigint e può essere usato in un calcolo numerico.

Input di esempio:

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

Output di esempio:

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

Query di esempio:

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

Usare un'istruzione CAST per specificare il tipo di dati. Consultare l'elenco dei Tipi di dati supportati nei Tipi di dati (Analisi di Flusso di Azure).

Per altre informazioni sulle funzioni di conversione dei dati.

Rilevare la durata di una condizione

Per le condizioni che si estendono su più eventi, è possibile usare la funzione LAG per identificare la durata di tale condizione. Si supponga, ad esempio, che un bug abbia generato un peso errato per tutte le automobili (oltre 20.000 libbre) e la durata di tale bug deve essere calcolata.

Input di esempio:

| 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 |

Output di esempio:

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

Query di esempio:

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 prima istruzione SELECT mette in correlazione la misurazione del peso corrente con la misura precedente, proiettandola insieme alla misura corrente. Il secondo select torna all'ultimo evento in cui il previous_weight è minore di 20000, dove il peso corrente è inferiore a 20000 e il previous_weight dell'evento corrente è maggiore di 20000.

Il End_fault è l'evento non predefinito corrente in cui l'evento precedente è difettoso e il Start_fault è l'ultimo evento non predefinito prima di tale evento.

Elaborare eventi con tempo indipendente (Substreams)

Gli eventi possono arrivare in ritardo o fuori ordine a causa di sfasamenti di clock tra produttori di eventi, sfasamenti di clock tra partizioni o latenza di rete. Ad esempio, l'orologio del dispositivo per TollID 2 è cinque secondi dietro TollID 1 e l'orologio del dispositivo per TollID 3 è di 10 secondi dietro TollID 1. Un calcolo può verificarsi in modo indipendente per ogni pedaggio, considerando solo i propri dati di orologio come riferimento temporale.

Input esempio:

| 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 |

Esempio di "output":

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

Esempio di query:

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

La clausola TIMESTAMP OVER BY esamina in modo indipendente ogni sequenza temporale del dispositivo usando sottostream. L'evento di output per ogni TollID viene generato mentre vengono calcolati, ovvero gli eventi sono in ordine rispetto a ogni TollID invece di essere riordinati come se tutti i dispositivi fossero nello stesso orologio.

Per altre informazioni, vedere TIMESTAMP BY OVER.

Finestre della sessione

Una finestra di sessione è una finestra che continua a espandersi man mano che si verificano gli eventi e si chiude per il calcolo se non viene ricevuto alcun evento dopo un periodo di tempo specifico o se la finestra raggiunge la durata massima. Questa finestra è particolarmente utile quando si calcolano i dati di interazione dell'utente. Una finestra inizia quando un utente inizia a interagire con il sistema e si chiude quando non vengono osservati altri eventi, ovvero l'utente ha smesso di interagire. Ad esempio, un utente interagisce con una pagina Web in cui viene registrato il numero di clic, è possibile usare una finestra di sessione per scoprire per quanto tempo l'utente ha interagito con il sito.

Input di esempio:

| 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" |

Output di esempio:

| 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 |

Query di esempio:

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 proietta i dati rilevanti per l'interazione dell'utente, insieme alla durata dell'interazione. Raggruppamento dei dati in base all'utente e a SessionWindow che si chiude se non viene eseguita alcuna interazione entro 1 minuto, con una dimensione massima della finestra di 60 minuti.

Per altre informazioni su SessionWindow, vedere Session Window .

Funzioni definite dall'utente in JavaScript e C#

Annotazioni

Questa sezione non si applica a Fabric Eventstream.

Il linguaggio di query di Analisi di flusso di Azure può essere esteso con funzioni personalizzate scritte in javaScript o in linguaggio C#. Le funzioni definite dall'utente sono calcoli personalizzati/complessi che non possono essere facilmente espressi usando il linguaggio SQL . Queste funzioni definite dall'utente possono essere definite una sola volta e usate più volte all'interno di una query. Ad esempio, un UDF può essere usato per convertire un valore nvarchar(max) esadecimale in un valore bigint.

Input di esempio:

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

Output di esempio:

| 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 funzione definita dall'utente calcola il valore bigint dall'HexValue per ogni evento consumato.

Per altre informazioni, vedere JavaScript e C#.

Criteri di ricerca avanzati con MATCH_RECOGNIZE

MATCH_RECOGNIZE è un meccanismo avanzato di ricerca di criteri che può essere usato per associare una sequenza di eventi a un criterio di espressione regolare ben definito. Ad esempio, un bancomat viene monitorato in tempo reale per gli errori, durante il funzionamento del bancomat se sono presenti due messaggi di avviso consecutivi che l'amministratore deve ricevere una notifica.

Input:

| 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 |

Output:

| 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

Questa query corrisponde ad almeno due eventi di errore consecutivi e genera un allarme quando vengono soddisfatte le condizioni. PATTERN definisce l'espressione regolare da usare per il confronto: almeno due avvisi consecutivi devono seguire almeno un'operazione riuscita. Il successo e l'avviso sono definiti usando il valore di Return_Code, quando la condizione è soddisfatta. Le misure** vengono proiettate con ATM_id, la prima operazione di avviso e il primo tempo di avviso.

Per altre informazioni, vedere MATCH_RECOGNIZE.

Geofencing e query geospaziali

Analisi di flusso di Azure offre funzioni geospaziali predefinite che possono essere usate per implementare scenari come la gestione della flotta, la condivisione delle corse, le automobili connesse e il rilevamento degli asset. I dati geospaziali possono essere inseriti in formati GeoJSON o WKT come parte dei dati eventstream o di riferimento. Ad esempio, un'azienda specializzata nella produzione di macchine per la stampa di passaporti, concede in leasing le proprie macchine ai governi e ai consolato. La posizione di queste macchine è strettamente controllata per evitare lo smarrimento e l'uso potenziale ai fini della contraffazione di passaporti. Ogni macchina è dotata di un localizzatore GPS, e le informazioni vengono inoltrate a un processo di Azure Stream Analytics. Il produttore desidera tenere traccia della posizione di tali macchine e ricevere un avviso se una di esse lascia un'area autorizzata. In questo modo, può disabilitarle a distanza, allertare le autorità e recuperare le apparecchiature.

Input:

| 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 |

Input dati di riferimento:

| 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))" |

Output:

| 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 query consente al produttore di monitorare automaticamente la posizione dei computer, ricevendo avvisi quando un computer lascia il recinto virtuale consentito. La funzione geospaziale predefinita consente agli utenti di usare i dati GPS all'interno della query senza librerie di terze parti.

Per ulteriori informazioni, consultare l'articolo Scenari di geofencing e aggregazione geospaziale con Azure Stream Analytics.

Ottenere assistenza

Per maggiore supporto, provare la Pagina delle domande di Domande e risposte Microsoft per Analisi di flusso di Azure.

Passaggi successivi

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-03-11

Condividi tramite

Modelli di query comuni in Analisi di flusso di Azure e Fabric Eventstream

Formati di dati supportati

Inviare dati a più output

Query pass-through semplice

Corrispondenza di stringhe con LIKE e NOT LIKE

Calcolo degli eventi precedenti

Restituire l'ultimo evento della finestra

Aggregazione dei dati nel tempo

Valori di output periodici

Correlare gli eventi in un flusso

Rilevare la durata tra gli eventi

Conta valori univoci

Recuperare il primo evento in una finestra

Rimuovere eventi duplicati in una finestra

Specificare la logica per casi/valori diversi (istruzioni CASE)

Conversione dei dati

Rilevare la durata di una condizione

Elaborare eventi con tempo indipendente (Substreams)

Finestre della sessione

Funzioni definite dall'utente in JavaScript e C#

Criteri di ricerca avanzati con MATCH_RECOGNIZE

Geofencing e query geospaziali

Ottenere assistenza

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive