Compartilhar via

Padrões de consulta comuns no Azure Stream Analytics

  • Artigo

As consultas no Azure Stream Analytics são expressas em uma linguagem de consulta parecida com o SQL. Essas construções de linguagem estão documentadas no guia Referência de linguagem de consulta do Stream Analytics.

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

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

Formatos de dados com suporte

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

Enviar dados para várias saídas

É possível usar várias instruções SELECT usadas para gerar dados de saída 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 blobs.

Considere a entrada a seguir:

| 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 seguintes saídas da consulta:

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 |

Consultar com duas instruções SELECT com saída de Camada de arquivos e saída de Alerta como resultados:

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. A primeira SELECT define uma consulta 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 alertas downstream chamada AlertOutput.

É possível usar a cláusula WITH para definir vários blocos de subconsultas. Essa opção tem o benefício 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, confira Cláusula WITH.

Consulta passagem simples

É possível usar uma consulta de passagem simples para copiar os dados de fluxo de entrada para a saída. Por exemplo, se um fluxo de dados contendo informações em tempo real de veículos precisar ser salvo em um banco de dados SQL para análise futura, uma simples consulta passagem fará isso.

Considere a entrada a seguir:

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

Uma consulta SELECT * projeta todos os campos de um evento de entrada e os envia para a saída. Em vez disso, você pode projetar apenas os campos necessários em uma instrução SELECT . No exemplo a seguir, a instrução SELECT projeta apenas os campos Modelo e Hora dos dados de entrada.

Considere a entrada a seguir:

| 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 Modelo e Hora:

| 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 necessários:

SELECT
	Make, Time
INTO Output
FROM Input

Correspondência de cadeia de caracteres 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 que começam com a letra A e terminam com o número 9.

Considere a entrada a seguir:

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

Veja 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. Ele deve começar com a letra A, seguida por qualquer sequência de zero ou mais caracteres e terminar com o número 9.

Cálculo de eventos passados

É possível usar a função LAG para examinar eventos passados dentro de uma janela de tempo e compará-los ao evento atual. Por exemplo, a marca do carro atual pode ser gerada se for diferente da marca do último carro que passou pela cabine de pedágio.

Entrada de exemplo:

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

Saída de exemplo:

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

Consulta de exemplo:

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

Use LAG para espiar o fluxo de entrada de um evento atrás, recuperando o valor Marca e comparando-o ao valor Marca do evento atual e gerar o evento.

Para obter mais informações, confira LAG.

Retorna o último evento de uma janela

Conforme 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 naquela janela de tempo. Para isso, o fluxo de entrada precisa ser unido a outro no ponto em que a hora de um evento seja o tempo máximo para todos os eventos nessa janela.

Entrada de exemplo:

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

Consulta de exemplo:

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 na 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 localizar o evento que corresponda 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, confira Funções de data.

Para obter mais informações sobre a união de fluxos, confira JOIN.

Agregação de dados ao longo do tempo

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

Entrada de exemplo:

| 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 de exemplo:

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

Consulta:

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

Essa agregação agrupa os carros por Modelo e os conta a cada 10 segundos. A saída apresenta o Modelo e a Contagem de carros que passaram pela cabine de pedágio.

TumblingWindow é uma função de exibição de janelas usada para agrupar eventos. As agregações podem ser aplicadas em todos os eventos agrupados. Para saber mais, confira funções de exibição de janelas.

Para obter mais informações sobre a agregação, confira Funções de agregação.

Valores de saída periódica

Quando os eventos são irregulares ou ausentes, 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 relatam o ponto de dados visto mais recentemente.

Entrada de exemplo:

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

Consulta de exemplo:

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 HOPPINGWINDOW determina por quanto tempo a consulta tenta encontrar o evento mais recente.

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

Correlacionar eventos presentes em um fluxo

É possível correlacionar eventos no mesmo fluxo por meio da análise de eventos passados usando a função LAG. Por exemplo, uma saída pode ser gerada sempre que dois carros consecutivos da mesma Marca passarem pela cabine de pedágio nos últimos 90 segundos.

Entrada de exemplo:

| 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 de exemplo:

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

Consulta de exemplo:

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 do evento anterior e recuperar o valor da Marca, comparando-o com o valor da Marca do evento atual. Assim que a condição for atendida, os dados do evento anterior poderão ser projetados usando a LAG na instrução SELECT.

Para obter mais informações, confira LAG.

Detectar a duração entre os eventos

A duração de um evento pode ser computada ao verificar o último evento de Início assim que um evento de Término for recebido. Essa consulta pode ajudar a determinar o tempo que um usuário gasta em uma página ou em um recurso.

Entrada de exemplo:

| 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 de exemplo:

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

Consulta de exemplo:

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'

É possível usar a função LAST para recuperar o último evento dentro de uma condição específica. Nesse exemplo, a condição é um evento do tipo Início, particionando a pesquisa por PARTITION BY usuário e recurso. Dessa forma, cada usuário e recurso é tratado de modo independente ao pesquisar o evento de início. LIMIT DURATION limita a hora de pesquisa em 1 hora atrás entre os eventos de Término e de Início.

Contagem de valores exclusivos

É possível usar COUNT e DISTINCT para contar a quantidade de valores de campo exclusivos que aparecem no fluxo em uma janela de tempo. Você pode criar uma consulta para calcular quantas Marcas de carro exclusivas passaram por uma cabine de pedágio em uma janela de dois segundos.

Entrada de exemplo:

| 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 de exemplo:

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

Consulta de exemplo:

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 Marca dentro de uma janela de tempo. Para obter mais informações, confira 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, a saída das informações do primeiro carro em cada intervalo de 10 minutos.

Entrada de exemplo:

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

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

Consulta de exemplo:

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 Marca de carro específica encontrada em cada intervalo de 10 minutos.

Saída de exemplo:

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

Consulta de exemplo:

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

Para obter mais informações, confira IsFirst.

Remover eventos duplicados em uma janela

Ao realizar 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 cópia do primeiro.

Entrada de exemplo:

| 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 de exemplo:

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

Consulta de exemplo:

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 único registro, pois os campos na cláusula “group by” são todos iguais. Portanto, ele remove as duplicatas.

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

Instruções CASE podem fornecer cálculos diferentes para campos diferentes com base em um critério específico. Por exemplo, atribua a faixa A a carros Make1 e a faixa B a qualquer outro modelo.

Entrada de exemplo:

| 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 de exemplo:

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

Consulta de exemplo:

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 com um conjunto de expressões simples para determinar seu resultado. Nesse exemplo, os veículos Make1 são enviados para a pista A, enquanto os veículos de qualquer outro modelo serão atribuídos à pista B.

Para obter mais informações, confira expressão case.

Conversão de dados

Os dados podem ser convertidos 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 exemplo:

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

Saída de exemplo:

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

Consulta de exemplo:

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 o tipo de dados. Veja a lista de tipos de dados com suporte em Tipos de dados (Azure Stream Analytics).

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

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

Para condições que abrangem vários eventos, é possível usar a função LAG para identificar a duração dessa condição. Por exemplo, suponha que um bug resultou no peso incorreto de todos os carros (acima de 9.000 quilos). Queremos calcular a duração do bug.

Entrada de exemplo:

| 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 de exemplo:

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

Consulta de exemplo:

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 medição de peso atual com a medida anterior, projetando-a junto com a medição atual. A segunda SELECT verifica o último evento em que o previous_weight é menor que 20.000, em que o peso atual é menor que 20.000 e o previous_weight do evento atual era maior que 20.000.

End_fault é o evento sem falha atual no qual o evento anterior tinha falha, e Start_fault é o último evento sem falha antes disso.

Processar eventos com hora independente (subfluxos)

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

Entrada de exemplo:

| 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 de exemplo:

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

Consulta de exemplo:

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

A cláusula TIMESTAMP BY OVER examina cada linha do tempo do dispositivo de modo independente usando subfluxos. O evento de saída para cada TollID é gerado conforme é computado, o que significa que os eventos estão na 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, confira TIMESTAMP BY OVER.

Janela de sessão

Uma janela de sessão é uma janela que continua se expandindo conforme os eventos ocorrem e fecha para computação caso nenhum evento seja recebido após um período específico ou caso a janela atinja sua duração máxima. Essa janela ajuda bastante ao computar dados de interação do usuário. Uma janela é iniciada quando um usuário começa a interagir com o sistema e é fechada quando não forem observados mais eventos, o que significa que o usuário parou de interagir. Por exemplo, um usuário está interagindo com uma página da Web em que 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 exemplo:

| 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 de exemplo:

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

Consulta de exemplo:

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)

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

Para obter mais informações sobre SessionWindow, confira Janela de sessão.

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

A linguagem de consulta do Azure Stream Analytics pode ser estendida com funções personalizadas escritas em JavaScript ou linguagem C#. As UDFs (funções definidas pelo usuário) são cálculos personalizados/complexos que não podem ser facilmente expressos usando a linguagem SQL. É possível definir essas UDFs uma vez e usá-las várias vezes em uma consulta. Por exemplo, é possível usar uma UDF para converter um valor hexadecimal nvarchar(max) em um valor bigint.

Entrada de exemplo:

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

Saída de exemplo:

| 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 computa o valor bigint do HexValue em todos os eventos consumidos.

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

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

MATCH_RECOGNIZE é um mecanismo de correspondência de padrões avançados 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á sendo monitorado em tempo real em busca de falhas e caso haja duas mensagens de aviso consecutivas durante sua operação, o administrador precisará 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 Success.Return_Code = 'Success',
		Warning AS Warning.Return_Code <> 'Success'
) AS patternMatch

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

Para obter mais informações, confira MATCH_RECOGNIZE.

Consultas de delimitação geográfica e geoespaciais

O Azure Stream Analytics fornece funções geoespaciais internas que podem ser usadas para implementar cenários como gerenciamento de frota, compartilhamento de caronas, carros conectados e acompanhamento de ativos. Os dados geoespaciais podem ser ingeridos em formatos GeoJSON ou WKT como parte do fluxo de eventos ou de dados de referência. Por exemplo, uma empresa especializada na fabricação de máquinas para a impressão de passaportes concede máquinas para agências governamentais e consulados. A localização dessas máquinas é muito controlada para evitar extravios e seu possível uso para a falsificação de passaportes. Cada máquina vem equipada com um rastreador GPS, cujas informações são retransmitidas para um trabalho do Azure Stream Analytics. O fabricante gostaria de monitorar a localização dessas máquinas e ser alertado caso uma delas saia de uma área autorizada. Dessa forma, ele poderá desabilitá-las 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_current_location, referenceInput.Equipment_lease_location) = 1

A consulta permite que o fabricante monitore a localização das máquinas automaticamente, recebendo alertas quando uma delas deixar a delimitação geográfica permitida. A função geoespacial interna permite aos usuários usarem dados de GPS dentro da consulta sem bibliotecas de terceiros.

Para obter mais informações, confira o artigo Cenários de delimitação geográfica e agregação geoespacial com Azure Stream Analytics.

Obter ajuda

Para obter mais assistência, confira nossa página de Perguntas e respostas do Microsoft do Azure Stream Analytics.

Próximas etapas