Padrões comuns de consulta no Azure Stream Analytics e Fabric Eventstream

Observação

O Fabric Eventstream é criado no mesmo runtime do Azure Stream Analytics. Portanto, os conceitos explicados neste artigo são aplicáveis ao Azure Stream Analytics e ao Fabric Eventstream.

As consultas no Azure Stream Analytics são expressas em uma linguagem de consulta semelhante a SQL. Os construções de linguagem são documentadas no guia de referência da 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 uma análise temporal e correspondência de padrões avançados para calcular agregações em várias janelas de tempo, como no guia Criar uma solução de IoT usando o guia do Stream Analytics . Você pode unir dados de várias entradas para combinar eventos de streaming e fazer pesquisas em dados de referência estáticos para enriquecer os valores do 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 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 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 gerar dados para coletores de saída diferentes. 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 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 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 |

Consulta com duas instruções SELECT tendo saída de Arquivo e saída de Alerta:

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 alertas downstream chamada AlertOutput.

A cláusula WITH pode ser usada para definir vários blocos de subconsulta. 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, consulte a cláusula WITH.

Consulta de passagem direta simples

Uma consulta de passagem simples pode ser usada para copiar os dados do fluxo de entrada para a saída. Por exemplo, se um fluxo de dados que contém informações de veículo em tempo real precisar ser salvo em um banco de dados SQL para análise posterior, uma consulta de passagem simples 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 igual à entrada:

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

Esta é a consulta:

SELECT
	*
INTO Output
FROM Input

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

SELECT
	Make, Time
INTO Output
FROM Input

Correspondência de strings 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 licença 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ê deseja que a saída contenha 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, em seguida, ter qualquer cadeia de caracteres de zero ou mais caracteres, terminando com o número 9.

Cálculo sobre eventos passados

A função LAG pode ser usada para examinar eventos passados em uma janela de tempo e compará-los com o evento atual. Por exemplo, a marca do carro atual pode ser exibida 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 um evento anterior, recuperando o valor Make e comparando-o com o valor Make do evento atual e emita 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 isso, o fluxo de entrada precisa ser unido a outro 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 para essa janela. A segunda etapa une os resultados da primeira consulta com o fluxo original para localizar 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 as 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 em 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 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 Make e os conta a cada 10 segundos. A saída apresenta a Marca e Contagem de carros que passaram pela cabine de pedágio.

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

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

Saída de valores periodicamente

Quando os eventos estão ausentes ou irregulares, uma saída de intervalo regular pode ser gerada a partir de uma entrada de dados menos densa. Por exemplo, gere um evento a cada 5 segundos que relata 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 que foi recebido anteriormente. A duração HOPPINGWINDOW determina até que ponto a consulta busca encontrar o evento mais recente.

Para obter mais informações, consulte a janela Hopping.

Correlacionar eventos em um fluxo

A correlação de eventos no mesmo fluxo pode ser feita examinando eventos passados usando a função LAG . Por exemplo, um resultado pode ser gerado 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 |

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

Para obter mais informações, consulte LAG.

Detectar a duração entre eventos

A duração de um evento pode ser computada examinando o último evento de Início quando um evento de Término é recebido. Essa consulta pode ser útil para determinar o tempo que um usuário passa em uma página ou 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'

A última função pode ser usada para recuperar o último evento dentro de uma condição específica. Neste exemplo, a condição é um evento do tipo Iniciar, 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 Inicialização. LIMIT DURATION limita a pesquisa de volta no tempo para 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 em uma janela de tempo. Você pode criar uma consulta para calcular quantos Carros exclusivos passaram pela cabine de pedágio em uma janela de 2 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 Make dentro de uma janela de tempo. Para obter mais informações, consulte a 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, exibindo as informações do primeiro carro a 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 carro específico Make encontrado a 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, consulte IsFirst.

Remover eventos duplicados em uma janela

Quando você executa uma operação, como calcular médias em 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 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, pois os campos no grupo por cláusula são todos iguais. Portanto, ele remove as duplicatas.

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

As 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 de Make1 e a faixa B a qualquer outra marca.

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

Para obter mais informações, consulte expressão de caso.

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 seu tipo de dados. Consulte 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, 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 computada.

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 |

Exemplo de query:

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 medida anterior, projetando-a junto com a medida atual. O segundo SELECT refere-se ao último evento em que o previous_weight é menor que 20000, onde o peso atual também é menor que 20000 e o previous_weight do evento atual foi maior do que 20000.

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

Processar eventos com tempo independente (Substreams)

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 TollID 2 está cinco segundos atrás do TollID 1 e o relógio do dispositivo para TollID 3 está 10 segundos atrás do TollID 1. Uma computação 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 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 |

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 analisa cada linha do tempo do dispositivo de forma independente usando substreams. O evento de saída para cada TollID é gerado conforme eles são computados, 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 se expandindo à medida que os eventos ocorrem e fecha para computação se nenhum evento for recebido após um período específico ou se a janela atingir sua duração máxima. Essa 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 há mais eventos observados, ou seja, 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 |

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 usuário, juntamente com a duração da interação. Agrupar os dados por usuário e um SessionWindow que será fechado 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, consulte Session Window .

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

Observação

Esta seção não se aplica ao Fabric Eventstream.

A linguagem de consulta do Azure Stream Analytics pode ser estendida com funções personalizadas escritas em linguagem JavaScript ou C#. UDF (Funções Definidas pelo Usuário) 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, uma UDF pode ser usada 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 calcula, em cada evento consumido, o valor bigint do HexValue.

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 caixa eletrônico está sendo monitorado em tempo real para falhas, durante a operação do caixa eletrônico se houver duas mensagens de aviso consecutivas que o administrador precisa 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 gera um alarme quando as condições são atendidas. PATTERN define a expressão regular a ser usada na correspondência, nesse caso, pelo menos dois avisos consecutivos após pelo menos uma operação bem-sucedida. Êxito e Aviso são definidos usando o valor Return_Code assim que a condição é atendida. As MEASURES** são projetadas com ATM_id, a operação inicial de aviso e o tempo de aviso inicial.

Para obter mais informações, consulte MATCH_RECOGNIZE.

Geofencing e consultas geoespaciais

O Azure Stream Analytics fornece funções geoespaciais internas que podem ser usadas para implementar cenários como gerenciamento de frota, compartilhamento de carona, carros conectados e acompanhamento de ativos. Os dados geoespaciais podem ser ingeridos em formatos GeoJSON ou WKT como parte de dados de referência ou fluxo de eventos. Por exemplo, uma empresa especializada em máquinas de fabricação para impressão de passaportes, aluga suas máquinas para governos e consulados. A localização dessas máquinas é fortemente controlada para evitar o extravio e o possível uso para falsificação de passaportes. Cada máquina é equipada com um rastreador GPS, e as informações são retransmitidas para um trabalho do Azure Stream Analytics. A fabricação gostaria de acompanhar a localização dessas máquinas e ser alertada se uma delas sair de uma área autorizada, dessa forma ela poderá desabilitar 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 dos computadores automaticamente, recebendo alertas quando um computador sai da cerca geográfica permitida. A função geoespacial interna permite que os usuários usem dados GPS dentro da consulta sem bibliotecas de terceiros.

Para obter mais informações, consulte o artigo cenários de geolocalização 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

Comentários

Esta página foi útil?

Last updated on 2026-03-11

Compartilhar via

Padrões comuns de consulta no Azure Stream Analytics e Fabric Eventstream

Formatos de dados com suporte

Enviar dados para várias saídas

Consulta de passagem direta simples

Correspondência de strings com LIKE e NOT LIKE

Cálculo sobre eventos passados

Retornar o último evento em uma janela

Agregação de dados ao longo do tempo

Saída de valores periodicamente

Correlacionar eventos em um fluxo

Detectar a duração entre eventos

Contar valores únicos

Recuperar o primeiro evento em uma janela

Remover eventos duplicados em uma janela

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

Conversão de dados

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

Processar eventos com tempo independente (Substreams)

Janelas de sessão

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

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

Geofencing e consultas geoespaciais

Obter ajuda

Próximas Etapas

Comentários

Recursos adicionais