Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Observação
O Fabric Eventstream é construído sobre o mesmo runtime do Azure Stream Analytics. Portanto, os conceitos explicados neste artigo são aplicáveis tanto ao Azure Stream Analytics como ao Fabric Eventstream.
As consultas no Azure Stream Analytics são expressas numa linguagem de consulta semelhante ao SQL. As construções linguísticas estão documentadas no guia de referência da linguagem de consulta Stream Analytics .
O design da consulta pode expressar uma transferência simples para mover dados de eventos de um fluxo de entrada para um armazenamento de dados de saída, ou realizar uma identificação abrangente de padrões e análise temporal para calcular agregados ao longo de várias janelas temporais, tal como descrito no guia Build an IoT solution by using Stream Analytics. Podes juntar dados de múltiplas entradas para combinar eventos de streaming, e podes fazer consultas com dados de referência estáticos para enriquecer os valores dos eventos. Também podes escrever dados para múltiplas saídas.
Este artigo apresenta soluções para vários padrões comuns de consulta baseados em cenários do mundo real.
Formatos de Dados Suportados
O Azure Stream Analytics suporta processamento de eventos em formatos de dados CSV, JSON e Avro. Os formatos JSON e Avro podem conter tipos complexos, como objetos aninhados (registos) ou arrays. Para mais informações sobre como trabalhar com estes tipos de dados complexos, consulte Análise de dados JSON e AVRO.
Enviar dados para múltiplas saídas
Múltiplas instruções SELECT podem ser usadas para enviar dados para diferentes sumidoiros de saída. Por exemplo, uma instrução SELECT pode emitir um alerta baseado em limiar, 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 queres os seguintes dois resultados 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 com saídas Arquivo e 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 indica ao serviço de Stream Analytics em qual das saídas deve escrever os dados. O primeiro SELECT define uma consulta pass-through que recebe dados da entrada e os envia para a saída chamada ArchiveOutput. A segunda consulta agrega e filtra os dados antes de enviar os resultados para um sistema de alertas a jusante chamado AlertOutput.
A cláusula WITH pode ser usada para definir múltiplos blocos de subconsulta. Esta opção tem a vantagem de abrir menos leitores à 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 mais informações, consulte a cláusula WITH.
Consulta de passagem direta simples
Uma simples consulta pass-through pode ser usada para copiar os dados do fluxo de entrada para a saída. Por exemplo, se um fluxo de dados contendo informação em tempo real do veículo precisar de ser guardado numa base de dados SQL para análise posterior, uma simples consulta pass-through faz 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" |
Queres 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 questão:
SELECT
*
INTO Output
FROM Input
Esta consulta SELECT * projeta todos os campos de um evento recebido e envia-os para a saída. Em vez disso, pode projetar apenas os campos necessários numa instrução SELECT . No exemplo seguinte, a instrução SELECT projeta apenas os campos Make e Time a partir 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 |
Queres 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 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, pode usar um filtro para devolver apenas as matrículas que começam pela 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 |
Queres que a saída tenha as matrículas 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á uma 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 uma sequência de zero ou mais caracteres, terminando com o número 9.
Cálculo sobre eventos passados
A função LAG pode ser usada para analisar eventos passados dentro de uma janela temporal e compará-los com o evento atual. Por exemplo, a marca do carro atual pode ser apresentada se for diferente da marca do último carro que passou pela portagem.
Exemplo de entrada:
| Make | Time |
| --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |
| Make2 |2023-01-01T00:00:02.0000000Z |
Exemplo de saída:
| 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 espreitar o fluxo de entrada um evento atrás, recuperando o valor Make e comparando-o com o valor Make do evento atual e gerando o evento.
Para mais informações, consulte LAG.
Devolver o último evento numa janela
Como os eventos são consumidos pelo sistema em tempo real, não existe uma função que possa determinar se um evento é o último a chegar nessa janela temporal. Para conseguir isto, o fluxo de entrada precisa de ser ligado a outro onde o tempo de um evento é o tempo máximo para todos os eventos nessa janela.
Exemplo de entrada:
| 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 |
Resultado de exemplo com informação sobre os últimos vagões 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
O primeiro passo da consulta encontra o carimbo temporal máximo em janelas de 10 minutos, ou seja, o carimbo temporal do último evento dessa janela. O segundo passo junta os resultados da primeira consulta ao fluxo original para encontrar o evento que corresponde aos últimos carimbos temporais em cada janela.
DATEDIFF é uma função específica de data que compara e devolve a diferença de tempo entre dois campos de DataHora; para mais informações, consulte funções de data.
Para mais informações sobre como aderir a streams, consulte JOIN.
Agregação de dados ao longo do tempo
Para calcular informação ao longo de uma janela temporal, 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.
Exemplo de 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 |
Exemplo de saída:
| 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 marca e conta-os a cada 10 segundos. A saída apresenta a marca e a contagem dos carros que passaram pela portagem.
TumblingWindow é uma função de janela usada para agrupar eventos. Uma agregação pode ser aplicada a todos os eventos agrupados. Para mais informações, consulte funções de janela.
Para mais informações sobre agregação, veja funções agregadas.
Valores de saída periodica
Quando os eventos estão em falta ou são irregulares, pode ser gerada uma saída de intervalo regular a partir de uma entrada de dados mais esparsa. Por exemplo, gerar um evento a cada 5 segundos que reporte o ponto de dados mais recentemente visto.
Exemplo de entrada:
| 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 |
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)
Esta consulta gera eventos a cada 5 segundos e gera o último evento que tinha sido recebido anteriormente. A duração do HOPPINGWINDOW determina até onde a consulta recua para encontrar o evento mais recente.
Para obter mais informações, consulte Hopping window.
Correlacionar eventos num stream
Correlacionar eventos no mesmo fluxo pode ser feito analisando eventos passados usando a função LAG . Por exemplo, pode ser gerado um resultado sempre que, nos últimos 90 segundos, dois carros consecutivos da mesma marca passem pela portagem.
Exemplo de entrada:
| 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 |
Exemplo de saída:
| 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 analisar o fluxo de entrada um evento atrás e recuperar o valor Make , comparando-o com o valor Make do evento atual. Uma vez cumprida a condição, os dados do evento anterior podem ser projetados usando LAG na instrução SELECT .
Para mais informações, consulte LAG.
Detetar a duração entre eventos
A duração de um evento pode ser calculada ao verificar o último evento Start após o recebimento de um evento End. Esta consulta pode ser útil para determinar o tempo que um utilizador passa numa página ou numa funcionalidade.
Exemplo de entrada:
| 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 |
Exemplo de saída:
| 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 PARTITION BY utilizador e funcionalidade. Desta forma, cada utilizador e funcionalidade são tratados de forma independente ao procurar o evento Start. DURAÇÃO LIMITADA limita a busca no tempo a 1 hora entre os eventos de Fim e Início.
Contagem de valores únicos
COUNT e DISTINCT podem ser usados para contar o número de valores únicos de campo que aparecem no fluxo dentro de uma janela temporal. Pode criar uma consulta para calcular quantas marcas únicas de carros passaram pela portagem numa janela de 2 segundos.
Exemplo de 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 |
Exemplo de saída:
| 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) devolve a contagem de valores distintos na coluna Make dentro de uma janela temporal. Para mais informações, consulte a função de agregação COUNT.
Recuperar o primeiro evento numa janela
Podes usar IsFirst para recuperar o primeiro evento numa janela de tempo. Por exemplo, enviar a informação do primeiro carro a cada 10 minutos.
Exemplo de entrada:
| 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 |
Exemplo de saída:
| 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 pode também particionar os dados e calcular o primeiro evento para cada marca específica de carro a cada intervalo de 10 minutos.
Exemplo de saída:
| 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 mais informações, consulte IsFirst.
Remover eventos duplicados numa janela
Quando realiza uma operação, como calcular médias sobre eventos numa dada janela temporal, os eventos duplicados devem ser filtrados. No exemplo seguinte, o segundo evento é um duplicado do primeiro.
Exemplo de entrada:
| 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 |
Exemplo de saída:
| 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 registos duplicados são combinados num só, pois os campos no grupo por cláusula são todos iguais. Assim, remove os duplicados.
Especificar lógica para diferentes casos/valores (instruções CASE)
As instruções CASE podem fornecer diferentes cálculos para diferentes áreas, com base em critérios específicos. Por exemplo, atribui faixa A a carros de Make1 e faixa B a qualquer outra marca.
Exemplo de entrada:
| Make | Time |
| --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |
| Make2 |2023-01-01T00:00:02.0000000Z |
| Make2 |2023-01-01T00:00:03.0000000Z |
Exemplo de saída:
| 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 com um conjunto de expressões simples para determinar o seu resultado. Neste exemplo, os veículos de Make1 são despachados para a faixa A, enquanto os veículos de qualquer outra marca serão atribuídos à faixa B.
Para mais informações, veja expressão de casos.
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 num cálculo numérico.
Exemplo de entrada:
| Make | Time | Weight |
| --- | --- | --- |
| Make1 |2023-01-01T00:00:01.0000000Z |"1000" |
| Make1 |2023-01-01T00:00:02.0000000Z |"2000" |
Exemplo de saída:
| 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 o seu tipo de dado. Consulte a lista de tipos de dados suportados em Tipos de Dados (Azure Stream Analytics).
Para mais informações sobre funções de conversão de dados.
Detetar a duração de uma condição
Para condições que abrangem múltiplos 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.
Exemplo de entrada:
| 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 |
Exemplo de saída:
| 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 declaração SELECT correlaciona a medição de peso atual com a medição anterior, projetando-a juntamente com a medição atual. O segundo SELECT recua para o último evento, onde o previous_weight é inferior a 20.000, onde o peso atual é inferior a 20.000 e o previous_weight do evento atual foi superior a 20.000.
O End_fault é o evento não defeituoso atual em que o evento anterior estava defeituoso, e o Start_fault é o último evento não defeituoso antes disso.
Eventos de processo com tempo independente (Substreams)
Os eventos podem chegar tarde ou fora de ordem devido a desfasamentos de relógio entre produtores de eventos, desfasamentos 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. O processamento pode ocorrer independentemente para cada portagem, considerando apenas os seus próprios dados de relógio como carimbo temporal.
Exemplo de entrada:
| 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 |
Exemplo de saída:
| 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 a linha temporal de cada dispositivo de forma independente usando substreams. O evento de saída para cada TollID é gerado à medida que são calculados, o que significa que os eventos estão em ordem relativamente a cada TollID em vez de serem reordenados como se todos os dispositivos estivessem no mesmo relógio.
Para 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 ocorrem eventos 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 utilizador. Uma janela começa quando um utilizador começa a interagir com o sistema e fecha quando não são observados mais eventos, ou seja, o utilizador deixou de interagir. Por exemplo, se um utilizador está a interagir com uma página web onde o número de cliques é registado, uma Janela de Sessão pode ser usada para saber quanto tempo o utilizador interagiu com o site.
Exemplo de entrada:
| 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" |
Exemplo de saída:
| 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 utilizador e uma SessionWindow que fecha se não houver interação dentro de 1 minuto, com um tamanho máximo de janela de 60 minutos.
Para mais informações sobre o SessionWindow, consulte Session Window .
Funções definidas pelo utilizador em JavaScript e C#
Observação
Esta secção não se aplica ao Fabric Eventstream.
A linguagem de consulta Azure Stream Analytics pode ser estendida com funções personalizadas escritas em JavaScript ou C#. As Funções Definidas pelo Utilizador (UDF) são cálculos personalizados/complexos que não podem ser facilmente expressos usando a linguagem SQL . Estes UDFs podem ser definidos uma vez e usados várias vezes dentro de uma consulta. Por exemplo, um UDF pode ser usado para converter um valor hexadecimal nvarchar(max) num valor bigint.
Exemplo de entrada:
| Device_id | HexValue |
| --- | --- |
| 1 | "B4" |
| 2 | "11B" |
| 3 | "121" |
Exemplo de saída:
| 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 User-Defined calcula o valor bigint a partir do HexValue em cada evento consumido.
Para 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 associar uma sequência de eventos a um padrão de expressão regular bem definido. Por exemplo, um caixa automático está a ser monitorizado em tempo real para falhas; se, durante o funcionamento, aparecerem duas mensagens de aviso consecutivas, 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
Esta consulta corresponde a pelo menos dois eventos consecutivos de falha e gera um alarme quando as condições são cumpridas. 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 pelo valor de Return_Code, uma vez que a condição é cumprida. As MEDIDAS** são projetadas com ATM_id, a primeira operação de aviso e o primeiro tempo de aviso.
Para mais informações, consulte MATCH_RECOGNIZE.
Geofencing e consultas geoespaciais
O Azure Stream Analytics fornece funções geoespaciais integradas que podem ser usadas para implementar cenários como gestão de frotas, partilha de viagens, carros ligados e rastreio de ativos. Os dados geoespaciais podem ser ingeridos em formatos GeoJSON ou WKT como parte de eventstream ou dados de referência. Por exemplo, uma empresa especializada na fabricação de máquinas para impressão de passaportes arrenda as suas máquinas a governos e consulados. A localização dessas máquinas é rigorosamente controlada para evitar o extravio e possível uso para falsificação de passaportes. Cada máquina está equipada com um rastreador GPS, e essa informação de localização é retransmitida para um trabalho do Azure Stream Analytics. O fabricante gostaria de monitorizar a localização dessas máquinas e ser alertado caso uma delas saia de uma área autorizada, podendo assim 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 |
Introdução 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 ao fabricante monitorizar automaticamente a localização da máquina, recebendo alertas quando uma máquina sai da geocerca permitida. A função geoespacial incorporada permite aos utilizadores usar dados GPS dentro da consulta sem bibliotecas de terceiros.
Para mais informações, consulte o artigo sobre Geofencing e cenários de agregação geoespacial com 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.