Modelli di query comuni in Analisi di flusso di Azure

Articolo
02/02/2024

Le query in Analisi di flusso di Azure sono espresse in un linguaggio di query di tipo SQL. Questi costrutti di linguaggio sono documentati nella guida Informazioni di riferimento sul linguaggio di query di Analisi di flusso.

La progettazione delle query può esprimere una semplice logica di pass-through per spostare i dati dell'evento da un flusso di input a un archivio dati di output oppure può eseguire criteri di ricerca avanzati e analisi temporali per calcolare le aggregazioni in varie finestre temporali, come nella guida Creare una soluzione IoT usando Analisi di flusso di Azure. È possibile aggiungere dati da più input per combinare flussi di eventi ed eseguire ricerche sui dati di riferimento statici per arricchire i valori degli eventi. È anche possibile scrivere dati per più output.

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

Formati di dati supportati

Analisi di flusso di Azure supporta l'elaborazione di eventi nei 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 restituire dati a sink di output diversi. Ad esempio, un'istruzione edizione Standard LECT può restituire un avviso basato su soglia, mentre un altro può restituire eventi in un archivio BLOB.

Considerare l'input seguente:

| 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 una query con due istruzioni edizione Standard LECT con output archive e output alert 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 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 un numero inferiore di lettori nell'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

Una semplice query pass-through può essere usata per copiare i dati del flusso di input nell'output. Ad esempio, se un flusso di dati contenenti informazioni sui veicoli in tempo reale deve essere salvato in un database SQL per un'analisi successiva, una semplice query pass-through esegue il processo.

Considerare l'input seguente:

| 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 edizione Standard LECT * proietta tutti i campi di un evento in ingresso e li invia all'output. È invece possibile proiettare solo i campi obbligatori in un'istruzione edizione Standard LECT. Nell'esempio seguente l'istruzione edizione Standard LECT proietta solo i campi Make and Time dai dati di input.

Considerare 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

Stringa corrispondente a LIKE e NOT LIKE

È possibile usare LIKE e NOT LIKE per verificare se un campo corrisponde a un determinato criterio. 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 verificare 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 sugli eventi passati

È possibile usare la funzione LAG per cercare gli eventi passati in una finestra temporale e confrontarli con l'evento corrente. Ad esempio, la produzione dell'auto corrente può essere restituita se è diversa da quella dell'ultima auto che passa 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 controllare il flusso di input dell'evento precedente, recuperando il valore Make e confrontandolo al valore Make dell'evento corrente, quindi restituire l'evento.

Per altre informazioni, vedere LAG.

Restituire l'ultimo evento in una 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 |

Output 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 altre informazioni sull'aggiunta di 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 di tempo per ogni macchina specifica.

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 automobili per Make (Marca) e le conteggia ogni 10 secondi. L'output ha il Make and Count delle auto che passavano attraverso il casello.

TumblingWindow è una funzione finestra usata per raggruppare gli eventi. È possibile applicare un'aggregazione a tutti gli eventi raggruppati. Per altre informazioni, vedere Funzioni finestra.

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. Generare, ad esempio, un evento ogni 5 secondi che segnali il punto di dati più recente individuato.

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 cinque secondi e restituisce l'ultimo evento ricevuto in precedenza. La durata HOPPINGWINDOW determina il raggio di ricerca della query nel passato per trovare l'evento più recente.

Per altre informazioni, vedere Finestra di salto.

Correlare gli eventi in un flusso

È possibile correlare gli eventi nello stesso flusso guardando gli eventi passati con 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ò analizzare il flusso di input dell'evento precedente e recuperare il valore Make, confrontandolo con il valore Make dell'evento corrente. Una volta raggiunta la condizione, è possibile proiettare i dati dell'evento precedente 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 di avvio dopo la ricezione di un evento di fine. Questa query può essere utile per determinare il tempo impiegato da un utente in una pagina o 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'

È possibile utilizzare la funzione LAST per recuperare l'ultimo evento in una condizione specifica. In questo esempio, la condizione è un evento di tipo Avvio, con partizionamento della ricerca per utente e 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 un'ora tra gli eventi di fine e di inizio.

contare valori univoci

È possibile usare COUNT e DISTINCT per contare il numero di valori di campo univoci presenti nel flusso in un intervallo di tempo. È possibile creare una query per calcolare il numero univoco di automobili che hanno passato 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 numero di valori distinti della colonna Make all'interno di una finestra temporale. 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, restituendo le informazioni sulla prima automobile 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 eseguire la partizione dei dati e calcolare il primo evento per ogni Marca di automobile specifica, rilevato a intervalli 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 gli 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 come i campi della clausola group by sono tutti uguali. Pertanto, rimuove i duplicati.

specificare la logica per i diversi casi/valori (istruzioni CASE)

Le istruzioni CASE possono fornire calcoli diversi per campi diversi, in base a un determinato criterio. Ad esempio, assegnare corsia A alle auto di Make1 e corsia B a qualsiasi altro make.

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 determinare 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 altre informazioni, vedere l'espressione case.

Conversione di 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 specificarne il tipo di dati. Visualizzare l'elenco dei tipi di dati supportati in 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. Ad esempio, si supponga che un bug abbia generato un peso errato per tutte le automobili (oltre 20.000 libbre) e che debba essere calcolata la durata di tale bug.

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 abbina la misurazione del peso corrente con quella precedente, proiettandola insieme alla misura corrente. La seconda istruzione SELECT esamina l'ultimo evento in cui il valore previous_weight era inferiore a 20.000, dove il peso corrente era inferiore a 20.000 e il valore previous_weight dell'evento corrente era maggiore di 20.000.

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 (substream)

gli eventi possono arrivare in ritardo o non in ordine a causa di sfasamenti di orario tra producer di eventi, sfasamenti di orario 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ò avvenire in modo indipendente per ogni casello, considerando solo i propri dati orari come timestamp.

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

Output di esempio:

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

Query di esempio:

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

la clausola TIMESTAMP OVER BY esamina la sequenza temporale di ogni dispositivo separatamente tramite substream. 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 delle sessioni

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 funzione è particolarmente utile quando si calcolano i dati di interazione degli utenti. Una finestra ha inizio quando un utente comincia a interagire con il sistema e si chiude quando non vengono più osservati eventi, ovvero quando l'utente ha cessato di interagire. Ad esempio, un utente interagisce con una pagina Web dove viene registrato il numero di clic. È possibile usare una Finestra sessione per scoprire quanto a lungo 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 utente insieme alla durata dell'interazione. Raggruppamento dei dati per utente e una SessionWindow che si chiude se non si verificano interazioni entro 1 minuto, con dimensioni massime della finestra di 60 minuti.

Per altre informazioni su SessionWindow, vedere Session Window .

Funzioni definite dall'utente in JavaScript e C#

È possibile estendere il linguaggio di query di Analisi di flusso di Azure con funzioni personalizzate scritte in JavaScript o C#. Le funzioni definite dall'utente sono calcoli personalizzati/complessi che non possono essere facilmente espressi usando il linguaggio SQL . Queste funzioni possono essere definite una volta e usate più volte all'interno di una query. Ad esempio, una funzione definita dall'utente può essere usata 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 da HexValue in ogni evento utilizzato.

Per altre informazioni, vedere JavaScript e C#.

Criteri di ricerca avanzati con MATCH_RECOGNIZE

MATCH_RECOGNIZE è un meccanismo avanzato di criteri di ricerca utilizzabile per associare una sequenza di eventi a un modello di espressione regolare ben definito. Ad esempio, un ATM viene monitorato in tempo reale in caso di errori. Se durante il suo funzionamento vengono generati due messaggi di avviso consecutivi, l'amministratore deve essere avvisato.

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 Succes.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 la corrispondenza, in questo caso almeno due avvisi consecutivi dopo almeno un'operazione riuscita. L'esito positivo e l'avviso vengono definiti usando Return_Code valore e una volta soddisfatta la condizione, le MISURE vengono proiettate con ATM_id, la prima operazione di avviso e la prima volta dell'avviso.

Per altre informazioni, vedere MATCH_RECOGNIZE.

Query geospaziali e di geofencing

Analisi di flusso di Azure offre funzioni geospaziali predefinite utilizzabili per implementare scenari quali gestione della flotta, condivisione delle corse, automobili connesse e rilevamento di asset. I dati geospaziali possono essere inseriti in formati GeoJSON o WKT come parte del flusso di eventi o dei dati 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 questi computer è controllata in modo rigoroso per evitare problemi di posizionamento e un possibile utilizzo per la contraffazione di passaporti. Ogni computer è dotato di un tracciatore GPS e queste informazioni vengono inviate nuovamente a un processo di Analisi di flusso di Azure. Il produttore desidera tenere traccia della posizione di tali computer e ricevere un avviso se uno di essi lascia un'area autorizzata, in questo modo può disabilitarlo da remoto, avvisare le autorità e recuperarlo.

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 dei 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_currenct_location, referenceInput.Equipment_lease_location) = 1

La query consente al produttore di monitorare automaticamente la posizione dei computer e di ricevere avvisi quando un computer lascia la rete geografica consentita. La funzione geospaziale predefinita consente agli utenti di usare i dati GPS all'interno della query senza librerie di terze parti.

Per altre informazioni, vedere l'articolo Scenari di aggregazione geofencing e geospaziale con Analisi di flusso di Azure.

Come ottenere assistenza

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

Condividi tramite

Modelli di query comuni in Analisi di flusso di Azure

Formati di dati supportati

inviare dati a più output

Query pass-through semplice

Stringa corrispondente a LIKE e NOT LIKE

Calcolo sugli eventi passati

Restituire l'ultimo evento in una finestra

Aggregazione dei dati nel tempo

Valori di output periodici

Correlare gli eventi in un flusso

rilevare la durata tra gli eventi

contare valori univoci

Recuperare il primo evento in una finestra

rimuovere gli eventi duplicati in una finestra

specificare la logica per i diversi casi/valori (istruzioni CASE)

Conversione di dati

rilevare la durata di una condizione

Elaborare eventi con tempo indipendente (substream)

Finestre delle sessioni

Funzioni definite dall'utente in JavaScript e C#

Criteri di ricerca avanzati con MATCH_RECOGNIZE

Query geospaziali e di geofencing

Come ottenere assistenza

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive