Após uma análise cuidadosa, decidimos descontinuar o Amazon Kinesis Data Analytics para aplicativos SQL: 1. A partir de **1º de setembro de 2025,** não forneceremos nenhuma correção de bug para aplicativos do Amazon Kinesis Data Analytics para SQL porque teremos suporte limitado para ele, devido à próxima descontinuação. 2. A partir **de 15 de outubro de 2025,** você não poderá criar novos aplicativos Kinesis Data Analytics para SQL. 3. Excluiremos as aplicações a partir de **27 de janeiro de 2026**. Você não poderá mais iniciar nem operar as aplicações do Amazon Kinesis Data Analytics para SQL. A partir dessa data, não haverá mais suporte ao Amazon Kinesis Data Analytics para SQL. Para obter mais informações, consulte [Descontinuação de aplicações do Amazon Kinesis Data Analytics para SQL](discontinuation.md). As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Conceitos de streaming com SQL O Amazon Kinesis Data Analytics implementa o padrão SQL ANSI 2008 com extensões. Essas extensões permitem o processamento de dados de streaming. Os tópicos a seguir abrangem os principais conceitos de streaming com SQL. **Topics** + [Bombas e fluxos no aplicativo](streams-pumps.md) + [Time stamps e a coluna ROWTIME](timestamps-rowtime-concepts.md) + [Consultas contínuas](continuous-queries-concepts.md) + [Consultas em janelas](windowed-sql.md) + [Operações de dados de streaming: associações de streams](stream-joins-concepts.md) # Bombas e fluxos no aplicativo Ao configurar a [entrada do aplicativo](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/how-it-works-input.html), mapeie uma origem de streaming para um fluxo no aplicativo que é criado. Os dados fluem continuamente da origem de streaming para o stream no aplicativo. Um stream no aplicativo funciona como uma tabela que você pode consultar usando instruções SQL, mas é chamado de stream porque representa o fluxo de dados contínuo. **nota** Não confunda fluxos na aplicação com fluxos de dados do Amazon Kinesis e fluxos de entrega do Firehose. Os streams no aplicativo existem apenas no contexto de um aplicativo do Amazon Kinesis Data Analytics. Os fluxos de dados do Kinesis e os fluxos de entrega do Firehose existem independentemente da aplicação. Você pode configurá-los como uma origem de streaming na configuração de entrada do aplicativo ou como um destino na configuração de saída. Também é possível criar mais fluxos no aplicativo, conforme necessário, para armazenar resultados de consulta intermediários. A criação de um stream no aplicativo é um processo de duas etapas. Primeiro, você cria um stream no aplicativo e, em seguida, bomba dados nele. Por exemplo, suponha que a configuração de entrada do aplicativo crie um fluxo no aplicativo chamado `INPUTSTREAM`. No exemplo a seguir, você cria outro stream (`TEMPSTREAM`) e, em seguida, bomba dados de `INPUTSTREAM` nele. 1. Crie um stream no aplicativo (`TEMPSTREAM`) com três colunas, como mostrado a seguir: ``` CREATE OR REPLACE STREAM "TEMPSTREAM" ( "column1" BIGINT NOT NULL, "column2" INTEGER, "column3" VARCHAR(64)); ``` Os nomes das colunas são especificados entre aspas, diferenciando maiúsculas de minúsculas. Para obter mais informações, consulte [Identificadores](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-identifiers.html) em *Amazon Kinesis Data Analytics SQL Reference*. 1. Insira dados no stream usando uma bomba. Uma bomba é uma consulta de inserção contínua em execução que insere dados de um stream no aplicativo em outro stream no aplicativo. A instrução a seguir cria uma bomba (`SAMPLEPUMP`) e insere dados em `TEMPSTREAM` selecionando registros de outro stream (`INPUTSTREAM`). ``` CREATE OR REPLACE PUMP "SAMPLEPUMP" AS INSERT INTO "TEMPSTREAM" ("column1", "column2", "column3") SELECT STREAM inputcolumn1, inputcolumn2, inputcolumn3 FROM "INPUTSTREAM"; ``` Você pode ter várias inserções de gravadores em um stream no aplicativo, e vários leitores selecionados no stream. Pense em um stream no aplicativo como uma implementação de um paradigma publish/subscribe de mensagens. Nesse paradigma, a linha de dados, incluindo o horário da criação e o horário do recebimento, pode ser processada, interpretada e encaminhada por uma cascata de instruções de streaming com SQL, sem a necessidade de ser armazenada em um RDBMS tradicional. Após criar um stream no aplicativo, você poderá executar consultas SQL normais. **nota** Ao consultar fluxos, a maioria das instruções SQL são vinculados usando uma janela baseada em linha ou em horário. Para obter mais informações, consulte [Consultas em janelas](windowed-sql.md). Você também pode associar streams. Para exemplos de associação, consulte [Operações de dados de streaming: associações de streams](stream-joins-concepts.md). # Time stamps e a coluna ROWTIME Os streams no aplicativo incluem uma coluna especial chamada `ROWTIME`. Ela armazena um timestamp quando o Amazon Kinesis Data Analytics insere uma linha no primeiro stream do aplicativo. `ROWTIME` reflete o timestamp no qual o Amazon Kinesis Data Analytics inseriu um registro no primeiro stream no aplicativo após ler a partir da fonte de streaming. Esse valor `ROWTIME` então é mantido em todo o aplicativo. **nota** Quando você bombeia registros de um stream no aplicativo para outro, não precisa copiar explicitamente a coluna `ROWTIME`, o Amazon Kinesis Data Analytics copia esta coluna para você. O Amazon Kinesis Data Analytics garante que os valores `ROWTIME` sejam monotonicamente aumentados. É possível usar esse time stamp nas consultas em janelas baseadas em tempo. Para obter mais informações, consulte [Consultas em janelas](windowed-sql.md). Você pode acessar a coluna ROWTIME na instrução `SELECT` como qualquer outra coluna no fluxo no aplicativo. Por exemplo: ``` SELECT STREAM ROWTIME, some_col_1, some_col_2 FROM SOURCE_SQL_STREAM_001 ``` ## Compreensão de vários horários da análise de streaming Além do `ROWTIME`, há outros tipos de horários em aplicativos de streaming em tempo real. Eles são: + **Horário do evento**: o time stamp em que o evento ocorreu. Isso também é às vezes chamado de *horário do cliente*. Muitas vezes, é desejável usar esse horário em análises, porque é o momento em que um evento ocorreu. No entanto, muitas fontes de eventos, como celulares e clientes da Web, não têm relógios confiáveis, o que pode levar a horários imprecisos. Além disso, problemas de conectividade podem levar a registros que aparecem em um stream não na mesma ordem em que os eventos ocorreram.   + **Horário de ingestão**: o time stamp de quando o registro foi adicionada à origem de streaming. O Amazon Kinesis Data Streams inclui um campo chamado `APPROXIMATE_ARRIVAL_TIME` em cada registro que fornece esse time stamp. Isso também é às vezes chamado de *horário do servidor*. Esse horário de inclusão normalmente está muito próximo do horário do evento. Se houver qualquer tipo de atraso na inclusão do registro no stream, pode haver imprecisões, que são normalmente raras. Além disso, o horário de inclusão raramente está fora de ordem, mas pode ocorrer devido à natureza distribuída dos dados de streaming. Portanto, o horário de inclusão é na maioria das vezes preciso e reflete a ordem do horário do evento.   + **Horário do processamento**: o time stamp quando o Amazon Kinesis Data Analytics insere uma linha no primeiro stream no aplicativo. O Amazon Kinesis Data Analytics fornece esse time stamp na coluna `ROWTIME` existente em cada stream no aplicativo. O tempo de processamento está sempre aumentando monotonicamente. Mas ele não será preciso se o aplicativo ficar atrasado. (Se um aplicativo ficar atrasado, o tempo de processamento não refletirá com precisão o horário do evento.) Esse `ROWTIME` é preciso em relação ao relógio, mas pode não representar o horário em que o evento realmente ocorreu. Usar cada um desses horários nas consultas em janelas baseadas em horário tem vantagens e desvantagens. Recomendamos que você escolha um ou mais desses horários e uma estratégia para lidar com as desvantagens relevantes de acordo com o caso de uso. **nota** Se você estiver usando janelas baseadas em linha, o horário não será um problema e você poderá ignorar esta seção. Recomendamos uma estratégia de duas janelas que usam dois horários, o `ROWTIME` e um dos outros horários (de inclusão ou do evento). + Use o `ROWTIME` como a primeira janela, que controla a frequência com que a consulta emite os resultados, como mostrado no exemplo a seguir. Ele não é usado como um horário lógico. + Use um dos outros horários lógicos que deseja associar à sua análise. Esse horário representa quando o evento ocorreu. No exemplo a seguir, o objetivo da análise é agrupar os registros e retornar a contagem pelo marcador. A vantagem dessa estratégia é que ela pode usar um horário que representa o momento em que o evento ocorreu. Ela pode lidar tranquilamente com atrasos de seu aplicativo ou com a chegada de eventos fora de ordem. Se o aplicativo atrasar ao colocar registros no stream no aplicativo, eles ainda estarão agrupados pelo horário lógico na segunda janela. A consulta usa o `ROWTIME` para garantir a ordem de processamento. Todos os registros atrasados (o time stamp de inclusão mostra um valor anterior comparado com o valor do `ROWTIME`) também são processados com êxito. Considere a seguinte consulta em relação ao fluxo de demonstração usado no [Exercício de conceitos básicos](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). A consulta usa a cláusula `GROUP BY` e emite uma contagem do marcador em uma janela em cascata de um minuto. ``` CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" ("ingest_time" timestamp, "APPROXIMATE_ARRIVAL_TIME" timestamp, "ticker_symbol" VARCHAR(12), "symbol_count" integer); CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM" SELECT STREAM STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '60' SECOND) AS "ingest_time", STEP("SOURCE_SQL_STREAM_001".APPROXIMATE_ARRIVAL_TIME BY INTERVAL '60' SECOND) AS "APPROXIMATE_ARRIVAL_TIME", "TICKER_SYMBOL", COUNT(*) AS "symbol_count" FROM "SOURCE_SQL_STREAM_001" GROUP BY "TICKER_SYMBOL", STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '60' SECOND), STEP("SOURCE_SQL_STREAM_001".APPROXIMATE_ARRIVAL_TIME BY INTERVAL '60' SECOND); ``` No `GROUP BY`, primeiro agrupe os registros baseados no `ROWTIME` em uma janela de um minuto e, em seguida, pelo `APPROXIMATE_ARRIVAL_TIME`. Os valores de time stamp no resultado são arredondados para baixo para o intervalo de 60 segundos mais próximo. O primeiro grupo de resultados emitidos pela consulta mostra registros no primeiro minuto. O segundo grupo de resultados emitidos mostra os registros nos próximos minutos com base no `ROWTIME`. O último registro indica que o aplicativo atrasou a entrega do registro no stream no aplicativo (ele mostra um valor `ROWTIME` atrasado em comparação com o time stamp de inclusão). ``` ROWTIME INGEST_TIME TICKER_SYMBOL SYMBOL_COUNT --First one minute window. 2016-07-19 17:05:00.0 2016-07-19 17:05:00.0 ABC 10 2016-07-19 17:05:00.0 2016-07-19 17:05:00.0 DEF 15 2016-07-19 17:05:00.0 2016-07-19 17:05:00.0 XYZ 6 –-Second one minute window. 2016-07-19 17:06:00.0 2016-07-19 17:06:00.0 ABC 11 2016-07-19 17:06:00.0 2016-07-19 17:06:00.0 DEF 11 2016-07-19 17:06:00.0 2016-07-19 17:05:00.0 XYZ 1 *** ***late-arriving record, instead of appearing in the result of the first 1-minute windows (based on ingest_time, it is in the result of the second 1-minute window. ``` É possível combinar os resultados de uma contagem final precisa por minuto enviando os resultados para um banco de dados de downstream. Por exemplo, é possível configurar a saída da aplicação para manter os resultados em um fluxo de entrega do Firehose que pode gravar em uma tabela do Amazon Redshift. Depois que os resultados estiverem em uma tabela do Amazon Redshift, será possível consultar esta tabela para calcular o grupo de contagem total pelo `Ticker_Symbol`. No caso do `XYZ`, o total é preciso (6\$11), mesmo que um registro chegue atrasado. # Consultas contínuas Uma consulta por um stream é executada continuamente pelos dados de streaming. Essa execução contínua permite cenários, como a capacidade de aplicativos consultarem continuamente um stream e gerar alertas. No exercício de Conceitos básicos, há um fluxo no aplicativo chamado `SOURCE_SQL_STREAM_001`. Ele recebe continuamente os preços de ações a partir de um fluxo de demonstração (um fluxo de dados do Kinesis). O esquema é o seguinte: ``` (TICKER_SYMBOL VARCHAR(4), SECTOR varchar(16), CHANGE REAL, PRICE REAL) ``` Suponha que você tenha interesse em alterações nos preços de ações acima de 15%. Você poderá usar a seguinte consulta no código do aplicativo. Essa consulta é executada continuamente e emite registros quando uma alteração acima de 15% é detectada no preço de uma ação. ``` SELECT STREAM TICKER_SYMBOL, PRICE FROM "SOURCE_SQL_STREAM_001" WHERE (ABS((CHANGE / (PRICE-CHANGE)) * 100)) > 15 ``` Use o procedimento a seguir para configurar um aplicativo do Amazon Kinesis Data Analytics e testar essa consulta. **Para testar a consulta** 1. Crie um aplicativo seguindo as instruções em [Exercício de conceitos básicos](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). 1. Substitua a instrução `SELECT` no código de aplicativo pela consulta `SELECT` anterior. O código de aplicativo resultante é mostrado a seguir: ``` CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (ticker_symbol VARCHAR(4), price DOUBLE); -- CREATE OR REPLACE PUMP to insert into output CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM" SELECT STREAM TICKER_SYMBOL, PRICE FROM "SOURCE_SQL_STREAM_001" WHERE (ABS((CHANGE / (PRICE-CHANGE)) * 100)) > 15; ``` # Consultas em janelas As consultas SQL no código de aplicativo são executadas continuamente em streams no aplicativo. Um fluxo no aplicativo representa dados não vinculados que fluem continuamente pelo aplicativo. Portanto, para que os conjuntos de resultados desta entrada sejam continuamente atualizados, as consultas são frequentemente vinculadas usando uma janela definida em termos de tempo ou linhas. Elas são também chamadas de *SQL em janelas*. Para obter uma consulta em janelas baseada em horário, especifique o tamanho da janela em termos de tempo (por exemplo, uma janela de um minuto). Isso requer uma coluna de time stamp no fluxo no aplicativo que aumente monotonicamente. (O time stamp de uma nova linha é maior ou igual ao da linha anterior.) O Amazon Kinesis Data Analytics fornece uma coluna de time stamp chamada `ROWTIME` para cada stream de aplicativo. É possível usar essa coluna especificando consultas baseadas em tempo. Para o seu aplicativo, escolha outra opção de time stamp. Para obter mais informações, consulte [Time stamps e a coluna ROWTIME](timestamps-rowtime-concepts.md). Para obter uma consulta em janela baseada em linha, especifique o tamanho da janela em termos do número de linhas. É possível especificar uma consulta para processar registros em uma janela em cascata, janela deslizante ou janela de escalonar, dependendo das necessidades do aplicativo. O Kinesis Data Analytics é compatível com os seguintes tipos de janela: + [Janelas de escalonamento](stagger-window-concepts.md): uma consulta que agrega dados usando janelas baseadas em horário com chave que abre com a chegada dos dados. As chaves permitem várias janelas sobrepostas. Essa é a maneira recomendada de agregar dados usando janelas baseadas em tempo, porque as janelas escalonadas reduzem os atrasos ou os out-of-order dados em comparação com as janelas Tumbling. + [Janelas em cascata](tumbling-window-concepts.md): uma consulta que agrega dados usando diferentes janelas baseadas em horário que abrem e fecham em intervalos regulares + [Janelas deslizantes](sliding-window-concepts.md): uma consulta que agrega dados continuamente, usando um horário fixo ou um intervalo de contagem de linhas. # Janelas de escalonamento Usar *janelas de escalonamento* é um método de janelas adequado para analisar grupos de dados que chegam em horários inconsistentes. Ele é ideal para qualquer caso de uso de análise de séries temporais, como um conjunto de vendas relacionadas ou registros de log. Por exemplo, os [logs de fluxo da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-logs-limitations) têm uma janela de captura de cerca de dez minutos. No entanto, podem ter uma janela de captura de até 15 minutos se você estiver agregando dados no cliente. As janelas de escalonamento são ideais para agregar esses logs para análise. As janelas de escalonamento resolvem o problema de registros relacionados sem cair na mesma janela de horário restrito, como quando as janelas em cascata eram usadas. ## Resultados parciais com janelas em cascata Há certas limitações no uso [Janelas em cascata](tumbling-window-concepts.md) para agregar out-of-order dados ou atrasos. Se as janelas em cascata são usados para analisar grupos de dados relacionados ao horário, os registros individuais podem ser colocados em janelas separadas. Portanto, os resultados parciais de cada janela devem ser combinados posteriormente a fim de produzir resultados completos para cada grupo de registros. Na consulta de janela em cascata a seguir, os registros são agrupados em janelas por rowtime, horário do evento e símbolo de índice: ``` CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" ( TICKER_SYMBOL VARCHAR(4), EVENT_TIME timestamp, TICKER_COUNT DOUBLE); CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM" SELECT STREAM TICKER_SYMBOL, FLOOR(EVENT_TIME TO MINUTE), COUNT(TICKER_SYMBOL) AS TICKER_COUNT FROM "SOURCE_SQL_STREAM_001" GROUP BY ticker_symbol, FLOOR(EVENT_TIME TO MINUTE), STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '1' MINUTE); ``` No diagrama a seguir, um aplicativo está contando o número de transações que recebe, com base em quando elas ocorreram (horário do evento) com um minuto de granularidade. O aplicativo pode usar uma janela em cascata para agrupar dados com base em rowtime e horário do evento. O aplicativo recebe quatro registros de que tudo chegou com um minuto entre um e outro. Ele agrupa os registros por rowtime, horário do evento e símbolo de índice. Como alguns registros chegam depois que a primeira janela em cascata termina, os registros não ficam na mesma janela em cascata de um minuto. ![\[Tumbling windows diagram showing data grouping by row time, event time, and ticker symbol over two minutes.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/stagger_0.png) O diagrama anterior tem os seguintes eventos. **** | ROWTIME | EVENT\$1TIME | TICKER\$1SYMBOL | | --- | --- | --- | | 11:00:20 | 11:00:10 | AMZN | | 11:00:30 | 11:00:20 | AMZN | | 11:01:05 | 11:00:55 | AMZN | | 11:01:15 | 11:01:05 | AMZN | O conjunto de resultados do aplicativo da janela em cascata é semelhante ao seguinte. **** | ROWTIME | EVENT\$1TIME | TICKER\$1SYMBOL | CONTAGEM | | --- | --- | --- | --- | | 11:01:00 | 11:00:00 | AMZN | 2 | | 11:02:00 | 11:00:00 | AMZN | 1 | | 11:02:00 | 11:01:00 | AMZN | 1 | No conjunto de resultados anterior, três resultados foram retornados: + Um registro com um `ROWTIME` de 11:01:00 que agrega os dois primeiros registros. + Um registro em 11:02:00 que agrega somente o terceiro registro. Esse registro tem um `ROWTIME` na segunda janela, mas um `EVENT_TIME` na primeira janela. + Um registro em 11:02:00 que agrega somente o quarto registro. Para analisar o conjunto de resultados completo, os registros devem ser agregados no armazenamento de persistência. Isso adiciona complexidade e requisitos de processamento ao aplicativo. ## Concluir resultados com janelas de escalonamento Para melhorar a precisão da análise dos registros de dados relacionados ao horário, o Kinesis Data Analytics oferece um novo tipo de janela chamado *janelas de escalonamento*. Nesse tipo de janela, as janelas abrem quando o primeiro evento relacionado à chave de partição chega e não em um intervalo de tempo fixo. As janelas fecham com base na idade especificada, que é medida a partir do horário em que a janela foi aberta. Uma janela de escalonamento é uma janela de restrição de horário separada para cada grupo de chaves em uma cláusula de janela. O aplicativo agrega cada resultado da cláusula de janela em sua própria janela de horário, em vez de usar uma única janela para todos os resultados. Na seguinte consulta em janela de escalonamento, os registros são agrupados em janelas por horário do evento e símbolo de índice: ``` CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" ( ticker_symbol VARCHAR(4), event_time TIMESTAMP, ticker_count DOUBLE); CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM" SELECT STREAM TICKER_SYMBOL, FLOOR(EVENT_TIME TO MINUTE), COUNT(TICKER_SYMBOL) AS ticker_count FROM "SOURCE_SQL_STREAM_001" WINDOWED BY STAGGER ( PARTITION BY FLOOR(EVENT_TIME TO MINUTE), TICKER_SYMBOL RANGE INTERVAL '1' MINUTE); ``` No seguinte diagrama, os eventos são agregados por horário do evento e símbolo de índice em janelas de escalonamento. ![\[Diagram showing event aggregation into stagger windows by event time and ticker symbol.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/stagger_1.png) O diagrama anterior tem os seguintes eventos, que são os mesmos eventos que o aplicativo da janela em cascata analisou: **** | ROWTIME | EVENT\$1TIME | TICKER\$1SYMBOL | | --- | --- | --- | | 11:00:20 | 11:00:10 | AMZN | | 11:00:30 | 11:00:20 | AMZN | | 11:01:05 | 11:00:55 | AMZN | | 11:01:15 | 11:01:05 | AMZN | O conjunto de resultados do aplicativo da janela de escalonamento é semelhante ao seguinte. **** | ROWTIME | EVENT\$1TIME | TICKER\$1SYMBOL | Contagem | | --- | --- | --- | --- | | 11:01:20 | 11:00:00 | AMZN | 3 | | 11:02:15 | 11:01:00 | AMZN | 1 | O registro retornado agrega os primeiros três registros de entrada. Os registros são agrupados por janelas de escalonamento de um minuto. A janela de escalonamento inicia quando o aplicativo recebe o primeiro registro AMZN (com um `ROWTIME` de 11:00:20). Quando a janela de escalonamento de um minuto expirar (às 11:01:20), um registro com os resultados que ficam na janela de escalonamento (com base em `ROWTIME` e `EVENT_TIME`) será gravado no fluxo de saída. Ao usar uma janela de escalonamento, todos os registros com `ROWTIME` e `EVENT_TIME` em uma janela de um minuto serão emitidos em um único resultado. O último registro (com um `EVENT_TIME` fora da agregação de um minuto) será agregado separadamente. Isso ocorre porque `EVENT_TIME` é uma das chaves de partição usada para separar os registros em conjuntos de resultados e a chave de partição de `EVENT_TIME` para a primeira janela é `11:00`. A sintaxe para uma janela de escalonamento é definida em uma cláusula especial, `WINDOWED BY`. Essa cláusula é usada em vez da cláusula `GROUP BY` para agregações de streaming. A cláusula aparece imediatamente após a cláusula opcional `WHERE` e antes da cláusula `HAVING`. A janela de escalonamento é definida na cláusula `WINDOWED BY` e considera dois parâmetros: chaves de partição e tamanho da janela. As chaves de partição particionam o streaming de dados de entrada e definem quando a janela abre. Uma janela de escalonamento abre quando o primeiro evento com uma chave de partição exclusiva aparece no fluxo. A janela de escalonamento fecha após um período fixo definido pelo tamanho da janela. A sintaxe é mostrada no seguinte exemplo de código: ``` ... FROM WHERE <... optional statements...> WINDOWED BY STAGGER( PARTITION BY RANGE INTERVAL ); ``` # Janelas em cascata (Agregações usando GROUP BY) Quando uma consulta em janela processa cada janela de forma não sobreposta, é chamada de *janela em cascata*. Nesse caso, cada registro em um fluxo no aplicativo pertence a uma janela específica. Ele é processado somente uma vez (quando a consulta processa a janela à qual o registro pertence). ![\[Timeline showing non-overlapping windows processing data streams at distinct time intervals.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/window-tumbling-20.png) Por exemplo, uma consulta de agregação que usa uma cláusula `GROUP BY` processa linhas em uma janela em cascata. O fluxo de demonstração no [exercício de conceitos básicos](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html) recebe os dados de preços de ações que são mapeados no fluxo no aplicativo `SOURCE_SQL_STREAM_001`. O stream tem o seguinte esquema: ``` (TICKER_SYMBOL VARCHAR(4), SECTOR varchar(16), CHANGE REAL, PRICE REAL) ``` Em seu código de aplicativo, suponha que você queira encontrar preços agregados (mínimo, máximo) para cada marcador em uma janela de um minuto. É possível usar a seguinte consulta. ``` SELECT STREAM ROWTIME, Ticker_Symbol, MIN(Price) AS Price, MAX(Price) AS Price FROM "SOURCE_SQL_STREAM_001" GROUP BY Ticker_Symbol, STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '60' SECOND); ``` Esse é um exemplo de consulta em janela baseada em horário. A consulta agrupa registros por valores de `ROWTIME`. Para relatórios por minuto, a função `STEP` arredonda os valores `ROWTIME` para baixo, para o minuto mais próximo. **nota** Você também pode usar a função `FLOOR` para agrupar registros em janelas. No entanto, `FLOOR` só pode arredondar os valores de tempo para uma unidade de tempo inteira (hora, minuto, segundo e assim por diante). `STEP` é recomendada para agrupar registros em janelas em cascata porque, assim, pode arredondar valores para baixo para um intervalo arbitrário, por exemplo, 30 segundos. Essa consulta é um exemplo de janela não sobreposta (em cascata). Os registros de grupos da cláusula `GROUP BY` em uma janela de um minuto e cada registro pertence a uma janela específica (não sobreposta). A consulta emite um registro de saída por minuto, fornecendo o preço do min/max ticker registrado no minuto específico. Esse tipo de consulta é útil para gerar relatórios periódicos do stream de dados de entrada. Neste exemplo, os relatórios são gerados a cada minuto. **Para testar a consulta** 1. Configure um aplicativo seguindo as instruções no [exercício de conceitos básicos](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). 1. Substitua a instrução `SELECT` no código de aplicativo pela consulta `SELECT` anterior. O código de aplicativo resultante é mostrado a seguir: ``` CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" ( ticker_symbol VARCHAR(4), Min_Price DOUBLE, Max_Price DOUBLE); -- CREATE OR REPLACE PUMP to insert into output CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM" SELECT STREAM Ticker_Symbol, MIN(Price) AS Min_Price, MAX(Price) AS Max_Price FROM "SOURCE_SQL_STREAM_001" GROUP BY Ticker_Symbol, STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '60' SECOND); ``` # Janelas deslizantes Em vez de agrupar registros usando `GROUP BY`, defina uma janela baseada em horário ou em linha. Para isso, adicione uma cláusula `WINDOW` explícita. Nesse caso, como a janela desliza com o tempo, o Amazon Kinesis Data Analytics emite uma saída quando novos registros aparecem no stream. O Kinesis Data Analytics emite essa saída ao processar as linhas na janela. As janelas podem se sobrepor neste tipo de processamento, e um registro pode fazer parte de várias janelas e ser processado em cada janela. O exemplo a seguir ilustra uma janela deslizante. Considere uma consulta simples que conta registros no stream. Este exemplo assume uma janela de cinco segundos. No stream de exemplo a seguir, novos registros chegam no horário t1, t2, t6, and t7, e três registros chegam no horário t8 segundos. ![\[Timeline showing record arrivals at t1, t2, t6, t7, and multiple at t8 within a 5-second window.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/sliding-10.png) Lembre-se do seguinte: + O exemplo assume uma janela de cinco segundos. A janela de 5 segundos desliza continuamente com o tempo. + Para cada linha que entra em uma janela, uma linha de saída é emitida pela janela deslizante. Logo após o aplicativo iniciar, a consulta emitirá uma saída para cada novo registro que aparecer no stream, embora uma janela de 5 segundos não tenha passado ainda. Por exemplo, a consulta emite a saída quando um registro aparece no primeiro segundo e no segundo. Mais tarde, a consulta processará registros na janela de 5 segundos. + As janelas deslizam com o tempo. Se um registro antigo no stream ficar fora da janela, a consulta não emitirá a saída, a menos que também haja um novo registro no stream que fique dentro da janela de 5 segundos. Suponha que a consulta comece a ser executada em t0. Ocorrerá o seguinte: 1. No horário t0, a consulta será iniciada. A consulta não emitirá a saída (valor da contagem), porque não haverá registros nesse horário. ![\[Timeline showing a stream starting at t0 with no output initially indicated.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/sliding-t0.png) 1. No momento t1, um novo registro aparece no stream e a consulta emite o valor de contagem 1. ![\[Timeline showing a stream with a record appearing at time t1, and an arrow pointing to t0.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/sliding-t1.png) 1. No momento t2, outro registro aparece e a consulta emite a contagem 2. ![\[Timeline showing stream events at different time points, with two vertical bars at the end.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/sliding-t2.png) 1. A janela de 5 segundos desliza com o tempo: + No t3, a janela deslizante t3 para t0 + No t4 (janela deslizante t4 para t0) + No t5, a janela deslizante t5 - t0 Em todos esses horários, a janela de 5 segundos tem os mesmos registros - não há novos registros. Portanto, a consulta não emite saídas. ![\[Timeline showing stream with multiple time points and colored rectangles representing data windows.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/sliding-t3-4-5.png) 1. No momento t6, a janela de 5 segundos é (t6 para t1). A consulta detecta um novo registro no t6; assim, ele emite a saída 2. O registro no t1 não está mais na janela e não conta. ![\[Timeline showing stream events at different time points with a sliding 5-second window.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/sliding-t6.png) 1. No momento t7, a janela de 5 segundos é t7 para t2. A consulta detecta um novo registro no t7; assim, ele emite a saída 2. O registro no t2 não está mais na janela de 5 segundos e, portanto, não é contado. ![\[Timeline showing stream events and time points from t0 to t7, with a 5-second window highlighted.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/sliding-t7.png) 1. No momento t8, a janela de 5 segundos é t8 para t3. A consulta detecta três novos registros e, portanto, emite a contagem de registro 5. ![\[Timeline showing stream events with orange bars representing record counts at different time intervals.\]](http://docs.aws.amazon.com/pt_br/kinesisanalytics/latest/dev/images/sliding-t8.png) Resumindo, a janela tem um tamanho fixo e desliza com o tempo. A consulta emite a saída quando novos registros são exibidos. **nota** Recomendamos que você use uma janela deslizante por não mais de uma hora. Se você usar uma janela maior, o aplicativo levará mais tempo para reiniciar após a manutenção regular do sistema. Isso ocorre porque os dados de origem precisam ser lidos no fluxo novamente. Os exemplos de consultas a seguir usam a cláusula `WINDOW` para definir janelas e executar agregados. Como as consultas não especificam o `GROUP BY`, a consulta usa a abordagem de janela deslizante para processar registros no stream. ## Exemplo 1: processar um fluxo usando uma janela deslizante de um minuto Considere o stream de demonstração no exercício de conceitos básicos que preenche o stream no aplicativo, `SOURCE_SQL_STREAM_001`. Este é o esquema. ``` (TICKER_SYMBOL VARCHAR(4), SECTOR varchar(16), CHANGE REAL, PRICE REAL) ``` Suponha que você queira que o aplicativo calcule os agregados usando uma janela deslizante de 1 minuto. Ou seja, para cada novo registro que aparecer no stream, você quer que o aplicativo emita uma saída aplicando agregados aos registros na janela de 1 minuto anterior. É possível usar as seguintes consultas em janela baseadas em horário. A consulta usa a cláusula `WINDOW` para definir o intervalo de 1 minuto. O `PARTITION BY` na cláusula `WINDOW` agrupa os registros por valores do marcador dentro da janela deslizante. ``` SELECT STREAM ticker_symbol, MIN(Price) OVER W1 AS Min_Price, MAX(Price) OVER W1 AS Max_Price, AVG(Price) OVER W1 AS Avg_Price FROM "SOURCE_SQL_STREAM_001" WINDOW W1 AS ( PARTITION BY ticker_symbol RANGE INTERVAL '1' MINUTE PRECEDING); ``` **Para testar a consulta** 1. Configure um aplicativo seguindo as instruções em [Exercício de conceitos básicos](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). 1. Substitua a instrução `SELECT` no código de aplicativo pela consulta `SELECT` anterior. O código de aplicativo resultante é o seguinte. ``` CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" ( ticker_symbol VARCHAR(10), Min_Price double, Max_Price double, Avg_Price double); CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM" SELECT STREAM ticker_symbol, MIN(Price) OVER W1 AS Min_Price, MAX(Price) OVER W1 AS Max_Price, AVG(Price) OVER W1 AS Avg_Price FROM "SOURCE_SQL_STREAM_001" WINDOW W1 AS ( PARTITION BY ticker_symbol RANGE INTERVAL '1' MINUTE PRECEDING); ``` ## Exemplo 2: agregações de aplicação de consulta em uma janela deslizante A consulta a seguir no stream de demonstração retorna a média de percentual de alteração no preço de cada marcador em uma janela de 10 segundos. ``` SELECT STREAM Ticker_Symbol, AVG(Change / (Price - Change)) over W1 as Avg_Percent_Change FROM "SOURCE_SQL_STREAM_001" WINDOW W1 AS ( PARTITION BY ticker_symbol RANGE INTERVAL '10' SECOND PRECEDING); ``` **Para testar a consulta** 1. Configure um aplicativo seguindo as instruções em [Exercício de conceitos básicos](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). 1. Substitua a instrução `SELECT` no código de aplicativo pela consulta `SELECT` anterior. O código de aplicativo resultante é o seguinte. ``` CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" ( ticker_symbol VARCHAR(10), Avg_Percent_Change double); CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM" SELECT STREAM Ticker_Symbol, AVG(Change / (Price - Change)) over W1 as Avg_Percent_Change FROM "SOURCE_SQL_STREAM_001" WINDOW W1 AS ( PARTITION BY ticker_symbol RANGE INTERVAL '10' SECOND PRECEDING); ``` ## Exemplo 3: dados de consulta de várias janelas deslizantes no mesmo stream É possível gravar consultas para emitir saída em que cada valor da coluna que é calculado usando diferentes janelas deslizantes definidas no mesmo stream. No exemplo a seguir, a consulta emite o marcador de saída, preço, a2 e a10. Ela emite a saída de símbolos de marcador cuja média de movimentação de duas cruza a média de movimentação de dez linhas. Os valores das colunas `a2` e `a10` são derivados de janelas deslizantes de duas linhas e dez linhas. ``` CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" ( ticker_symbol VARCHAR(12), price double, average_last2rows double, average_last10rows double); CREATE OR REPLACE PUMP "myPump" AS INSERT INTO "DESTINATION_SQL_STREAM" SELECT STREAM ticker_symbol, price, avg(price) over last2rows, avg(price) over last10rows FROM SOURCE_SQL_STREAM_001 WINDOW last2rows AS (PARTITION BY ticker_symbol ROWS 2 PRECEDING), last10rows AS (PARTITION BY ticker_symbol ROWS 10 PRECEDING); ``` Para testar essa consulta em relação ao stream de demonstração, siga o procedimento de teste descrito no [Exemplo 1](#sliding-ex1). # Operações de dados de streaming: associações de streams É possível ter vários streams no aplicativo em seu aplicativo. Você pode gravar consultas `JOIN` para correlacionar os dados que chegam nesses streams. Por exemplo, suponha que você tenha os seguintes fluxos no aplicativo: + **OrderStream**— Recebe pedidos de estoque sendo feitos. ``` (orderId SqlType, ticker SqlType, amount SqlType, ROWTIME TimeStamp) ``` + **TradeStream**— Recebe as negociações de ações resultantes desses pedidos. ``` (tradeId SqlType, orderId SqlType, ticker SqlType, amount SqlType, ticker SqlType, amount SqlType, ROWTIME TimeStamp) ``` Estes são exemplos de consulta `JOIN` que correlacionam os dados desses streams. ## Exemplo 1: relata pedidos com transações realizadas até um minuto após os pedidos serem feitos Neste exemplo, a consulta associa o `OrderStream` e o `TradeStream`. No entanto, como queremos apenas as transações feitas um minuto após os pedidos, a consulta define a janela de 1 minuto pelo `TradeStream`. Para obter informações sobre consultas em janelas, veja [Janelas deslizantes](sliding-window-concepts.md). ``` SELECT STREAM ROWTIME, o.orderId, o.ticker, o.amount AS orderAmount, t.amount AS tradeAmount FROM OrderStream AS o JOIN TradeStream OVER (RANGE INTERVAL '1' MINUTE PRECEDING) AS t ON o.orderId = t.orderId; ``` É possível definir as janelas explicitamente usando a cláusula `WINDOW` e gravando a consulta anterior da seguinte forma: ``` SELECT STREAM ROWTIME, o.orderId, o.ticker, o.amount AS orderAmount, t.amount AS tradeAmount FROM OrderStream AS o JOIN TradeStream OVER t ON o.orderId = t.orderId WINDOW t AS (RANGE INTERVAL '1' MINUTE PRECEDING) ``` Quando você incluir essa consulta no código do aplicativo, esse código será executado continuamente. O aplicativo emitirá uma saída para cada registro que chegar no `OrderStream`, se houver transações dentro da janela de 1 minuto após o pedido ser feito. A associação na consulta anterior é uma associação interna, na qual a consulta emite registros no `OrderStream` com registros correspondentes no `TradeStream` (e vice-versa). Usando uma associação externa, crie outro cenário interessante. Suponha que você queira pedidos de ações para as quais não há transações em até um minuto da realização do pedido, e transações relatadas na mesma janela, mas para outros pedidos. Este é um exemplo de *associação externa*. ``` SELECT STREAM ROWTIME, o.orderId, o.ticker, o.amount AS orderAmount, t.ticker, t.tradeId, t.amount AS tradeAmount, FROM OrderStream AS o LEFT OUTER JOIN TradeStream OVER (RANGE INTERVAL '1' MINUTE PRECEDING) AS t ON o.orderId = t.orderId; ```