Padrões de consulta comuns no Azure Stream Analytics

  • Artigo

As consultas no Azure Stream Analytics são expressas numa linguagem de consultas do tipo SQL. As construções de linguagem são documentadas no guia de referência de linguagem de consulta do Stream Analytics.

O design da consulta pode expressar uma lógica de passagem simples para mover dados de eventos de um fluxo de entrada para um armazenamento de dados de saída, ou pode fazer correspondência de padrões avançada e análise temporal para calcular agregações em várias janelas de tempo, como no guia Criar uma solução IoT usando o guia do Stream Analytics . Você pode unir dados de várias entradas para combinar eventos de streaming e pode fazer pesquisas em dados de referência estáticos para enriquecer os valores de evento. Você também pode gravar dados em várias saídas.

Este artigo descreve soluções para vários padrões de consulta comuns com base em cenários do mundo real.

Formatos de dados suportados

O Azure Stream Analytics dá suporte ao processamento de eventos nos formatos de dados CSV, JSON e Avro. Os formatos JSON e Avro podem conter tipos complexos, como objetos aninhados (registros) ou matrizes. Para obter mais informações sobre como trabalhar com esses tipos de dados complexos, consulte Análise de dados JSON e AVRO.

Enviar dados para várias saídas

Várias instruções SELECT podem ser usadas para exportar dados para diferentes coletores de saída. Por exemplo, uma instrução SELECT pode gerar um alerta baseado em limite, enquanto outra pode gerar eventos para um armazenamento de blob.

Considere a seguinte entrada:

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

E você deseja as duas saídas a seguir da consulta:

ArquivoSaída:

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

Consulta com duas instruções SELECT com saída Archive e saída Alert como saídas:

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

A cláusula INTO informa ao serviço Stream Analytics em qual das saídas gravar os dados. O primeiro SELECT define uma consulta de passagem que recebe dados da entrada e os envia para a saída chamada ArchiveOutput. A segunda consulta agrega e filtra dados antes de enviar os resultados para uma saída do sistema de alerta downstream chamada AlertOutput.

A cláusula WITH pode ser usada para definir vários blocos de subconsulta. Esta opção tem a vantagem de abrir menos leitores para a fonte de entrada.

Consulta:

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

Para obter mais informações, consulte Cláusula COM.

Consulta de passagem simples

Uma simples consulta de passagem pode ser usada para copiar os dados do fluxo de entrada para a saída. Por exemplo, se um fluxo de dados contendo informações do veículo em tempo real precisar ser salvo em um banco de dados SQL para análise posterior, uma simples consulta de passagem fará o trabalho.

Considere a seguinte entrada:

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

Você deseja que a saída seja a mesma que a entrada:

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

Aqui está a consulta:

SELECT
	*
INTO Output
FROM Input

Esta consulta SELECT * projeta todos os campos de um evento de entrada e envia-os para a saída. Em vez disso, você pode projetar apenas os campos obrigatórios em uma instrução SELECT . No exemplo a seguir, a instrução SELECT projeta apenas os campos Make e Time dos dados de entrada.

Considere a seguinte entrada:

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

Você deseja que a saída tenha apenas os campos Make e Time:

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

Aqui está a consulta que projeta apenas os campos obrigatórios:

SELECT
	Make, Time
INTO Output
FROM Input

Correspondência de cordas com LIKE e NOT LIKE

LIKE e NOT LIKE podem ser usados para verificar se um campo corresponde a um determinado padrão. Por exemplo, você pode usar um filtro para retornar apenas as placas de veículos que começam com a letra A e terminam com o número 9.

Considere a seguinte entrada:

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

Você quer que a saída tenha as placas que começam com a letra A e terminam com o número 9:

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

Aqui está a consulta que usa o operador LIKE:

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

Use a instrução LIKE para verificar o valor do campo License_plate . Deve começar com a letra A, depois ter qualquer sequência de zero ou mais caracteres, terminando com o número 9.

Cálculo sobre eventos passados

A função GAL pode ser utilizada para analisar acontecimentos passados dentro de uma janela temporal e compará-los com o acontecimento atual. Por exemplo, marca do carro atual pode ser saída se for diferente da marca do último carro que passou pela cabine de pedágio.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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

Use o LAG para espiar o fluxo de entrada um evento de volta, recuperando o valor Make e comparando-o com o valor Make do evento atual e produzindo o evento.

Para obter mais informações, consulte LAG.

Retornar o último evento em uma janela

Como os eventos são consumidos pelo sistema em tempo real, não há nenhuma função que possa determinar se um evento é o último a chegar para essa janela de tempo. Para conseguir isso, o fluxo de entrada precisa ser unido com outro onde a hora de um evento é o tempo máximo para todos os eventos nessa janela.

Entrada de amostra:

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

Saída de amostra com informações sobre os últimos carros em duas janelas de tempo de dez minutos:

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

Exemplo de consulta:

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

A primeira etapa da consulta localiza o carimbo de data/hora máximo em janelas de 10 minutos, ou seja, o carimbo de data/hora do último evento dessa janela. A segunda etapa une os resultados da primeira consulta com o fluxo original para encontrar o evento que corresponde aos últimos carimbos de data/hora em cada janela.

DATEDIFF é uma função específica de data que compara e retorna a diferença de tempo entre dois campos DateTime, para obter mais informações, consulte funções de data.

Para obter mais informações sobre como ingressar em fluxos, consulte JOIN.

Agregação de dados ao longo do tempo

Para calcular informações ao longo de uma janela de tempo, você pode agregar os dados. Neste exemplo, a instrução calcula uma contagem nos últimos 10 segundos de tempo para cada marca específica de um carro.

Entrada de amostra:

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

Saída da amostra:

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

Consulta:

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

Esta agregação agrupa os carros por Make e conta-os a cada 10 segundos. A saída tem o Make and Count dos carros que passaram pela cabine de pedágio.

TumblingWindow é uma função de janela usada para agrupar eventos. Uma agregação pode ser aplicada a todos os eventos agrupados. Para obter mais informações, consulte funções de janela.

Para obter mais informações sobre agregação, consulte funções agregadas.

Saída periódica de valores

Quando os eventos estão ausentes ou irregulares, uma saída de intervalo regular pode ser gerada a partir de uma entrada de dados mais esparsa. Por exemplo, gere um evento a cada 5 segundos que relata o ponto de dados visto mais recentemente.

Entrada de amostra:

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

Saída de amostra (primeiras 10 linhas):

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

Exemplo de consulta:

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)

Essa consulta gera eventos a cada 5 segundos e gera o último evento recebido anteriormente. A duração da janela HOPPING determina até que ponto a consulta procura para encontrar o evento mais recente.

Para obter mais informações, consulte Janela de salto.

Correlacionar eventos em um fluxo

A correlação de eventos no mesmo fluxo pode ser feita olhando para eventos passados usando a função LAG . Por exemplo, uma saída pode ser gerada toda vez que dois carros consecutivos da mesma marca passam pela cabine de pedágio nos últimos 90 segundos.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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

A função LAG pode examinar o fluxo de entrada um evento de volta e recuperar o valor Make , comparando-o com o valor Make do evento atual. Uma vez satisfeita a condição, os dados do evento anterior podem ser projetados usando LAG na instrução SELECT .

Para obter mais informações, consulte LAG.

Detetar a duração entre eventos

A duração de um evento pode ser calculada observando o último evento Start quando um evento End é recebido. Essa consulta pode ser útil para determinar o tempo que um usuário gasta em uma página ou um recurso.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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'

A função LAST pode ser usada para recuperar o último evento dentro de uma condição específica. Neste exemplo, a condição é um evento do tipo Start, particionando a pesquisa por usuário e recurso PARTITION BY . Dessa forma, cada usuário e recurso são tratados de forma independente ao pesquisar o evento Start. LIMIT DURATION limita a pesquisa de volta no tempo a 1 hora entre os eventos End e Start.

Contar valores únicos

COUNT e DISTINCT podem ser usados para contar o número de valores de campo exclusivos que aparecem no fluxo dentro de uma janela de tempo. Você pode criar uma consulta para calcular quantas marcas únicas de carros passaram pela cabine de pedágio em uma janela de 2 segundos.

Entrada de amostra:

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

Saída da amostra :

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

Exemplo de consulta:

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

COUNT(DISTINCT Make) retorna a contagem de valores distintos na coluna Make dentro de uma janela de tempo. Para obter mais informações, consulte Função de agregação COUNT.

Recuperar o primeiro evento em uma janela

Você pode usar IsFirst para recuperar o primeiro evento em uma janela de tempo. Por exemplo, emitindo as primeiras informações do carro a cada intervalo de 10 minutos.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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

IsFirst também pode particionar os dados e calcular o primeiro evento para cada carro específico Make encontrado a cada intervalo de 10 minutos.

Saída da amostra:

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

Exemplo de consulta:

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

Para obter mais informações, consulte IsFirst.

Remover eventos duplicados em uma janela

Quando você executa uma operação, como calcular médias sobre eventos em uma determinada janela de tempo, os eventos duplicados devem ser filtrados. No exemplo a seguir, o segundo evento é uma duplicata do primeiro.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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 a primeira instrução é executada, os registros duplicados são combinados em um, pois os campos na cláusula group by são todos iguais. Portanto, ele remove as duplicatas.

Especificar lógica para diferentes casos/valores (instruções CASE)

As instruções CASE podem fornecer diferentes cálculos para diferentes campos, com base em critérios específicos. Por exemplo, atribuir faixa A para carros de Make1 e pista B para qualquer outra marca.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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

A expressão CASE compara uma expressão a um conjunto de expressões simples para determinar seu resultado. Neste exemplo, os veículos de são despachados para a faixa A enquanto os veículos de qualquer outra marca serão atribuídos faixa B.Make1

Para obter mais informações, consulte expressão de maiúsculas e minúsculas.

Conversão de dados

Os dados podem ser transmitidos em tempo real usando o método CAST . Por exemplo, o peso do carro pode ser convertido do tipo nvarchar(max) para o tipo bigint e ser usado em um cálculo numérico.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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

Use uma instrução CAST para especificar seu tipo de dados. Consulte a lista de tipos de dados suportados em Tipos de dados (Azure Stream Analytics).

Para obter mais informações sobre funções de conversão de dados.

Detetar a duração de uma condição

Para condições que se estendem por vários eventos, a função LAG pode ser usada para identificar a duração dessa condição. Por exemplo, suponha que um bug resultou em todos os carros com um peso incorreto (acima de 20.000 libras), e a duração desse bug deve ser calculada.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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

A primeira instrução SELECT correlaciona a medida de peso atual com a medição anterior, projetando-a juntamente com a medição atual. O segundo SELECT remete para o último evento em que o previous_weight é inferior a 20000, onde o peso atual é inferior a 20000 e o previous_weight do evento atual foi superior a 20000.

O End_fault é o evento não defeituoso atual em que o evento anterior foi defeituoso, e o Start_fault é o último evento não defeituoso antes disso.

Processar eventos com tempo independente (Subfluxos)

Os eventos podem chegar atrasados ou fora de ordem devido a distorções de relógio entre produtores de eventos, distorções de relógio entre partições ou latência de rede. Por exemplo, o relógio do dispositivo para o TollID 2 está cinco segundos atrás do TollID 1 e o relógio do dispositivo para o TollID 3 está 10 segundos atrás do TollID 1. Um cálculo pode acontecer de forma independente para cada pedágio, considerando apenas seus próprios dados de relógio como um carimbo de data/hora.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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

A cláusula TIMESTAMP OVER BY examina cada linha do tempo do dispositivo de forma independente usando subfluxos. O evento de saída para cada TollID é gerado à medida que são calculados, o que significa que os eventos estão em ordem em relação a cada TollID em vez de serem reordenados como se todos os dispositivos estivessem no mesmo relógio.

Para obter mais informações, consulte TIMESTAMP BY OVER.

Janelas de sessão

Uma janela de sessão é uma janela que continua a expandir-se à medida que os eventos ocorrem e fecha para cálculo se nenhum evento for recebido após um determinado período de tempo ou se a janela atingir a sua duração máxima. Esta janela é particularmente útil ao calcular dados de interação do usuário. Uma janela começa quando um usuário começa a interagir com o sistema e fecha quando não são observados mais eventos, ou seja, o usuário parou de interagir. Por exemplo, um usuário está interagindo com uma página da Web onde o número de cliques é registrado, uma janela de sessão pode ser usada para descobrir por quanto tempo o usuário interagiu com o site.

Entrada de amostra:

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

Saída da amostra:

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

Exemplo de consulta:

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)

O SELECT projeta os dados relevantes para a interação do utilizador, juntamente com a duração da interação. Agrupar os dados por usuário e uma SessionWindow que fecha se nenhuma interação acontecer dentro de 1 minuto, com um tamanho máximo de janela de 60 minutos.

Para obter mais informações sobre SessionWindow, consulte Session Window .

Funções definidas pelo usuário em JavaScript e C#

A linguagem de consulta do Azure Stream Analytics pode ser estendida com funções personalizadas escritas em JavaScript ou linguagem C#. As Funções Definidas pelo Usuário (UDF) são cálculos personalizados/complexos que não podem ser facilmente expressos usando a linguagem SQL . Essas UDFs podem ser definidas uma vez e usadas várias vezes em uma consulta. Por exemplo, um UDF pode ser usado para converter um valor hexadecimal nvarchar(max) em um valor bigint .

Entrada de amostra:

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

Saída da amostra:

| 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

A função definida pelo usuário calcula o valor bigint do HexValue em cada evento consumido.

Para obter mais informações, consulte JavaScript e C#.

Correspondência avançada de padrões com MATCH_RECOGNIZE

MATCH_RECOGNIZE é um mecanismo avançado de correspondência de padrões que pode ser usado para corresponder uma sequência de eventos a um padrão de expressão regular bem definido. Por exemplo, um ATM está a ser monitorizado em tempo real para falhas, durante o funcionamento do ATM se houver duas mensagens de aviso consecutivas o administrador precisa de ser notificado.

Entrada:

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

Saída:

| 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

Essa consulta corresponde a pelo menos dois eventos de falha consecutivos e gera um alarme quando as condições são atendidas. PATTERN define a expressão regular a ser usada na correspondência, neste caso, pelo menos dois avisos consecutivos após pelo menos uma operação bem-sucedida. Sucesso e Aviso são definidos usando Return_Code valor e, uma vez que a condição é atendida, as MEDIDAS são projetadas com ATM_id, a primeira operação de aviso e a primeira hora de aviso.

Para obter mais informações, consulte MATCH_RECOGNIZE.

Geofencing e consultas geoespaciais

O Azure Stream Analytics fornece funções geoespaciais incorporadas que podem ser utilizadas para implementar cenários como gestão de frotas, partilha de viagens, carros ligados e rastreio de ativos. Os dados geoespaciais podem ser ingeridos nos formatos GeoJSON ou WKT como parte do fluxo de eventos ou dados de referência. Por exemplo, uma empresa especializada na fabricação de máquinas para impressão de passaportes, aluga suas máquinas para governos e consulados. A localização dessas máquinas é fortemente controlada, a fim de evitar o extravio e a possível utilização para a contrafação de passaportes. Cada máquina é equipada com um rastreador GPS, essas informações são retransmitidas de volta para um trabalho do Azure Stream Analytics. O fabricante gostaria de acompanhar a localização dessas máquinas e ser alertado se uma delas sair de uma área autorizada, desta forma eles podem desativar remotamente, alertar as autoridades e recuperar o equipamento.

Entrada:

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

Entrada de dados de referência:

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

Saída:

| 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

A consulta permite que o fabricante monitore a localização das máquinas automaticamente, recebendo alertas quando uma máquina sai da cerca geográfica permitida. A função geoespacial integrada permite que os usuários usem dados GPS dentro da consulta sem bibliotecas de terceiros.

Para obter mais informações, consulte o artigo Geofencing and geospatial aggregation scenarios with Azure Stream Analytics .

Obter ajuda

Para obter mais assistência, experimente a nossa página de perguntas e respostas da Microsoft para o Azure Stream Analytics.

Próximos passos