Tras considerarlo detenidamente, hemos decidido dejar de utilizar Amazon Kinesis Data Analytics para aplicaciones SQL: 1. A partir del **1 de septiembre de 2025,** no proporcionaremos ninguna corrección de errores para las aplicaciones de Amazon Kinesis Data Analytics for SQL porque tendremos un soporte limitado debido a la próxima discontinuación. 2. A partir del **15 de octubre de 2025,** no podrá crear nuevas aplicaciones de Kinesis Data Analytics for SQL. 3. Eliminaremos sus aplicaciones a partir del **27 de enero de 2026**. No podrá iniciar ni utilizar sus aplicaciones de Amazon Kinesis Data Analytics para SQL. A partir de ese momento, el servicio de soporte de Amazon Kinesis Data Analytics para SQL dejará de estar disponible. Para obtener más información, consulte [Retirada de las aplicaciones de Amazon Kinesis Data Analytics para SQL](discontinuation.md). Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Conceptos de SQL de Streaming Amazon Kinesis Data Analytics implementa el estándar ANSI 2008 SQL con extensiones. Estas extensiones le permiten procesar los datos de streaming. Los siguientes temas cubren de los conceptos clave de SQL de streaming. **Topics** + [Secuencias y bombeos en la aplicación](streams-pumps.md) + [Marcas temporales y la comuna ROWTIME](timestamps-rowtime-concepts.md) + [Consultas continuas](continuous-queries-concepts.md) + [Consultas en ventana](windowed-sql.md) + [Operaciones de streaming de datos: uniones de secuencias](stream-joins-concepts.md) # Secuencias y bombeos en la aplicación Al configurar la [entrada de aplicación](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/how-it-works-input.html), asigna el origen de streaming a una secuencia en la aplicación que se crea. La información fluye desde el origen de streaming en la secuencia en la aplicación. Una secuencia en la aplicación funciona como una tabla que puede consultar a través de instrucciones SQL, pero se denomina una secuencia ya que representa un flujo de datos continuo. **nota** No confunda los flujos en la aplicación con los flujos de datos de Amazon Kinesis Data Streams y los flujos de entrega de Firehose. Las secuencias en la aplicación existen solo en el contexto de una aplicación de Amazon Kinesis Data Analytics. Los flujos de datos de Kinesis y los flujos de entrega de Firehose existen independientemente de su aplicación. Puede configurarlas como un origen de streaming en la configuración de entrada de su aplicación o como destino en la configuración de salida. También puede crear más secuencias en la aplicación como se necesite, para almacenar resultados intermedios de consultas. La creación de una secuencia en la aplicación es un proceso de dos pasos. En primer lugar, debe crear una secuencia en la aplicación y, a continuación, se envían datos a ella. Por ejemplo, suponga que la configuración de entrada de la aplicación crea una secuencia en la aplicación llamada `INPUTSTREAM`. En el siguiente ejemplo, debe crear otra secuencia (`TEMPSTREAM`) y, a continuación, envíe datos desde `INPUTSTREAM` a la misma. 1. Crear una secuencia en la aplicación (`TEMPSTREAM`) con tres columnas, tal y como se muestra a continuación: ``` CREATE OR REPLACE STREAM "TEMPSTREAM" ( "column1" BIGINT NOT NULL, "column2" INTEGER, "column3" VARCHAR(64)); ``` Los nombres de columna se especifican entre comillas, de manera que distingue entre mayúsculas y minúsculas. Para obtener más información, consulte [Identificadores](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-identifiers.html) en la *Referencia de SQL de Amazon Kinesis Data Analytics*. 1. Insertar datos a la secuencia mediante una bomba. Una bomba es una consulta continua, que inserta información de una secuencia en la aplicación a otra secuencia en la aplicación. La siguiente instrucción crea una bomba (`SAMPLEPUMP`) e introduce los datos en `TEMPSTREAM` seleccionando registros de otra secuencia (`INPUTSTREAM`). ``` CREATE OR REPLACE PUMP "SAMPLEPUMP" AS INSERT INTO "TEMPSTREAM" ("column1", "column2", "column3") SELECT STREAM inputcolumn1, inputcolumn2, inputcolumn3 FROM "INPUTSTREAM"; ``` Puede tener varios escritores insertados en una secuencia en la aplicación, y puede haber varios lectores seleccionados de la secuencia. Piense en una transmisión dentro de la aplicación como la implementación de un paradigma publish/subscribe de mensajería. En este paradigma, la fila de datos, incluida la hora de creación y la hora de la recepción, puede ser procesada, interpretada y reenviada por una cascada de instrucciones SQL de streaming, sin tener que estar almacenada en un RDBMS tradicional. Una vez creada una secuencia en la aplicación, puede realizar consultas SQL normales. **nota** Cuando se consultan secuencias, la mayoría de las instrucciones SQL se unen usando una ventana basada en filas o en el tiempo. Para obtener más información, consulte [Consultas en ventana](windowed-sql.md). También puede unir secuencias. Para ver ejemplos de cómo unir secuencias, consulte [Operaciones de streaming de datos: uniones de secuencias](stream-joins-concepts.md). # Marcas temporales y la comuna ROWTIME Las secuencias en la aplicación incluyen una columna especial llamada `ROWTIME`. Almacena una marca temporal cuando Amazon Kinesis Data Analytics inserta una fila en la primera secuencia en la aplicación. `ROWTIME` refleja la marca temporal en la que Amazon Kinesis Data Analytics insertó un registro en la primera secuencia en la aplicación después de leer desde el origen de streaming. Este valor `ROWTIME` se mantiene en toda su aplicación. **nota** Cuando se bombean registros de una secuencia en la aplicación a otra, no es necesario copiar la columna `ROWTIME` porque ya lo hace Amazon Kinesis Data Analytics. Amazon Kinesis Data Analytics garantiza que los valores de `ROWTIME` aumentan de forma monotómica. Puede utilizar esta marca temporal en las consultas en ventana basadas en el tiempo. Para obtener más información, consulte [Consultas en ventana](windowed-sql.md). Puede tener acceso a la columna ROWTIME en la instrucción `SELECT` al igual que con cualquier otra columna de la secuencia en la aplicación. Por ejemplo: ``` SELECT STREAM ROWTIME, some_col_1, some_col_2 FROM SOURCE_SQL_STREAM_001 ``` ## Descripción de los distintos tiempos en análisis de streaming Además de `ROWTIME`, existen otros tipos de tiempo en aplicaciones de streaming en tiempo real. Estos son: + **Tiempo de eventos**: la marca temporal de cuando se produjo el evento. A esto también se le llama el lado de tiempo *del cliente*. Suele ser conveniente utilizar estos momentos en análisis, ya que es el momento en el que se produjo un evento. No obstante, muchas fuentes de eventos como, por ejemplo, clientes de teléfonos móviles y web, no tienen relojes de confianza, lo que puede provocar tiempos inexactos. Además, los problemas de conectividad pueden hacer que los registros aparezcan en la secuencia y no lo en el mismo orden los eventos.   + **Tiempo de ingestión**: la marca temporal de cuándo se añadió un registro a un origen de streaming. Amazon Kinesis Data Streams incluye un campo llamado `APPROXIMATE_ARRIVAL_TIME` en todos los registros que proporciona esta marca temporal. Esto también se denomina a veces *tiempo del servidor*. Este tiempo de ingestión suele ser una aproximación cercana al tiempo de evento. Si existe algún tipo de retraso en la adquisición de registros en la secuencia, se pueden producir inexactitudes, que suelen ser raras. Además, el tiempo de ingestión no suele estar fuera de lugar, si bien eso puede ocurrir debido a la naturaleza distribuida del streaming de datos. Por lo tanto, el tiempo de ingestión es un reflejo bastante preciso y en orden del tiempo de evento.   + Tiempo de procesamiento: la marca temporal de cuando Amazon Kinesis Data Analytics inserta un fila en la primera secuencia en la aplicación. Amazon Kinesis Data Analytics proporciona esta marca temporal en la columna `ROWTIME` de cada secuencia en la aplicación. El tiempo de procesamiento aumenta siempre de forma monótona. Sin embargo, no será preciso si la aplicación se rezaga. (Si una aplicación se rezaga, el tiempo de procesamiento no refleja con precisión la hora del evento). Este `ROWTIME` es preciso en relación con el reloj, pero podría no ser el momento en el que el evento en que el evento realmente ocurrió. Utilizar cada uno de estos tiempos en las consultas en ventana basadas en el tiempo tiene ventajas y desventajas. Le recomendamos que elija uno o varios de estos tiempos, y una estrategia para abordar las posibles desventajas en función de su caso de uso. **nota** Si utiliza ventanas basadas en filas, el tiempo no será un problema y puede ignorar esta sección. Recomendamos una estrategia de dos ventanas que utilice dos ventanas basadas en el tiempo: una `ROWTIME` y una para los otros tiempos (tiempo de ingestión o de evento). + Utilice `ROWTIME` como la primera ventana, que controla la frecuencia con la que la consulta emite los resultados, tal y como se muestra en el siguiente ejemplo. No se utiliza como tiempo lógico. + Utilice uno de los otros tiempos que es el tiempo lógico que desea asociar a su análisis. Este tiempo representa cuándo se produjo el evento. En el siguiente ejemplo, el objetivo de análisis es agrupar los registros y devolver un recuento por cada símbolo. La ventaja de esta estrategia es que puede utilizar una hora que represente cuándo se produjo el evento. Puede gestionar adecuadamente situaciones en las que la aplicación se queda rezagada o cuando los eventos llegan desordenados. Si la aplicación se rezaga al traer registros en la secuencia en la aplicación, estos se siguen agrupando por el momento lógico en la segunda ventana. La consulta utiliza `ROWTIME` para garantizar el orden de procesamiento. Los registros que están retrasados (la marca temporal de ingestión muestra un valor anteriores comparación con el `ROWTIME` valor) también se procesan correctamente. Considere realizar la siguiente consulta con a la secuencia de demostración utilizada en el ejercicio de [introducción](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). La consulta utiliza la cláusula `GROUP BY` y emite el recuento de cada símbolo en una ventana de saltos de un 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); ``` En `GROUP BY`, primero agrupe los registros según `ROWTIME` en una ventana de un minuto y, a continuación, según `APPROXIMATE_ARRIVAL_TIME`. Los valores de marca temporal del resultado se redondean hacia abajo al intervalo de 60 segundos más próximo. El primer grupo de resultados emitido por la consulta muestra registros del primer minuto. El segundo grupo de resultados emitido muestra registros de los minutos siguientes según `ROWTIME`. El último registro indica que la aplicación se retrasó al traer el registro en la secuencia en la aplicación (muestra un valor `ROWTIME` con retraso en comparación la marca temporal de la ingestión). ``` 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. ``` Puede combinar los resultados para obtener un recuento preciso por minuto insertando los resultados en una base de datos posterior. Por ejemplo, puede configurar la salida de la aplicación para que conserve los resultados en un flujo de entrega de Firehose que pueda escribir en una tabla de Amazon Redshift. Una vez que los resultados estén en la tabla de Amazon Redshift puede consultar la tabla para calcular el grupo de recuento total por `Ticker_Symbol`. En el caso de `XYZ`, el total es correcto (6\$11), aunque un registro haya llegado tarde. # Consultas continuas Una consulta a través de una secuencia se ejecuta de forma continua en los datos de streaming. Esta ejecución continua hace posibles situaciones como la capacidad de las aplicaciones para consultar continuamente una secuencia y generar alertas. En el ejercicio de introducción, dispone de una secuencia en la aplicación denominada `SOURCE_SQL_STREAM_001`. Recibe constantemente los precios de valores a partir de una secuencia de demostración (un flujo de datos de Kinesis). El esquema es el siguiente: ``` (TICKER_SYMBOL VARCHAR(4), SECTOR varchar(16), CHANGE REAL, PRICE REAL) ``` Supongamos que está interesado en los cambios de cotizaciones superiores al 15 por ciento. Puede utilizar la siguiente consulta en el código de la aplicación. Esta consulta se ejecuta sin interrupción y emite registros cuando se detecta un cambio en las cotizaciones superior al 15 por ciento. ``` SELECT STREAM TICKER_SYMBOL, PRICE FROM "SOURCE_SQL_STREAM_001" WHERE (ABS((CHANGE / (PRICE-CHANGE)) * 100)) > 15 ``` Utilice el siguiente procedimiento para configurar una aplicación de Amazon Kinesis Data Analytics y probar esta consulta. **Para probar la consulta** 1. Cree una aplicación siguiendo el [ejercicio de introducción](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). 1. Sustituya la instrucción `SELECT` en el código de la aplicación por la consulta `SELECT` anterior. El código de la aplicación resultante se muestra a continuación: ``` 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 en ventana Las consultas SQL en el código de la aplicación pueden ejecutarse de forma continua a través de secuencias en la aplicación. En una secuencia en la aplicación representa un datos ilimitados que fluyen de forma continua a través de su aplicación. Por lo tanto, para obtener resultados de esta salida que se actualiza de forma constante, a menudo se unen consultas utilizando una ventana definida en términos de tiempo o de filas. Estas también se denominan *SQL en ventana*. Para una consulta en ventana basada en el tiempo, debe especificar el tamaño de la ventana expresado en unidades de tiempo (por ejemplo, una ventana de un minuto). Esto requiere una columna de marca temporal en la secuencia en la aplicación que aumente de forma monótona. (La marca de tiempo de una fila nueva es superior o igual a la fila anterior.) Amazon Kinesis Data Analytics proporciona una columna de marca temporal llamada `ROWTIME` para cada secuencia en la aplicación. Puede utilizar esta columna al especificar las consultas basadas en el tiempo. Para su aplicación, puede elegir otra opción de marca temporal. Para obtener más información, consulte [Marcas temporales y la comuna ROWTIME](timestamps-rowtime-concepts.md). Para una consulta en ventana basada en filas, debe especificar el tamaño de la ventana expresado como un número de filas. Puede especificar una consulta para procesar registros en una ventana de saltos, una ventana deslizante una ventana escalonada, según las necesidades de la aplicación. Kinesis Data Analytics admite los siguientes tipos de ventanas: + [Ventanas escalonadas](stagger-window-concepts.md): una consulta que agrupa los datos usando ventanas basadas en tiempo con clave que se abren cuando llegan los datos. Las claves permiten que se superpongan varias ventanas. Esta es la forma recomendada de agregar datos mediante ventanas basadas en el tiempo, ya que Stagger Windows reduce el retraso o out-of-order los datos en comparación con las ventanas giratorias. + [Ventanas de saltos de tamaño constante](tumbling-window-concepts.md): una consulta que agrupa los datos usando ventanas de tiempo que se abren y cierran a intervalos regulares. + [Ventanas deslizantes](sliding-window-concepts.md): una consulta que agrega datos continuamente, utilizando un intervalo de tiempo fijo o de número de filas. # Ventanas escalonadas El uso de las *ventanas escalonadas* es un método de definición de ventanas adecuado para analizar grupos de datos que llegan erráticamente. Es ideal para cualquier caso de uso de análisis de series temporales, como un conjunto de ventas relacionadas o registros de un archivo de registros. Por ejemplo, [Registros de flujo de VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-logs-limitations) tiene una ventana de captura de 10 minutos aproximadamente. Sin embargo, pueden tener una ventana de captura de hasta 15 minutos si acumula datos en el cliente. Las ventanas escalonadas son ideales para agrupar estos registros para su análisis. Las ventanas escalonadas solucionan el problema de los registros relacionados no incluidos en la misma ventana de tiempo restringido, por ejemplo, si se han utilizado ventanas de saltos. ## Resultados parciales con ventanas de saltos El uso [Ventanas de saltos de tamaño constante](tumbling-window-concepts.md) para agregar out-of-order datos o datos tiene ciertas limitaciones. Si las ventanas de saltos se utilizan para analizar grupos de datos relacionados con el tiempo, los registros individuales podrían caer en ventanas separadas. Por lo tanto, los resultados parciales de cada ventana se deben combinar más tarde para ofrecer resultados completos para cada grupo de registros. En la siguiente consulta de ventana de saltos, los registros se agrupan en ventanas por hora de fila, hora del evento y clave de cotización: ``` 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); ``` En el siguiente diagrama, una aplicación cuenta el número de operaciones que recibe, en función del momento en que se han producido las operaciones (hora del evento) con un grado de detalle de un minuto. La aplicación puede utilizar una ventana de saltos para agrupar los datos en función de la hora de la fila y la hora del evento. La aplicación recibe cuatro registros que llegan minuto a minuto. Agrupa los registros por hora de la fila, hora del evento y clave de cotización. Como algunos de los registros llegan después de que termine la primera ventana de saltos, los registros no entrarán todos en la misma ventana de saltos de un minuto. ![\[Tumbling windows diagram showing data grouping by row time, event time, and ticker symbol over two minutes.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/stagger_0.png) El diagrama anterior tiene los siguientes 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 | El conjunto de resultados de la aplicación de la ventana de saltos tiene un aspecto similar al siguiente. **** | ROWTIME | EVENT\$1TIME | TICKER\$1SYMBOL | COUNT | | --- | --- | --- | --- | | 11:01:00 | 11:00:00 | AMZN | 2 | | 11:02:00 | 11:00:00 | AMZN | 1 | | 11:02:00 | 11:01:00 | AMZN | 1 | En el conjunto de resultados anterior, se devuelven tres resultados: + Un registro con un `ROWTIME` de 11:01:00 que agrupa los dos primeros registros. + Un registro a las 11:02:00 que agrupa solo el tercer registro. Este registro tiene un `ROWTIME` dentro de la segunda ventana, pero un `EVENT_TIME` dentro de la primera ventana. + Un registro a las 11:02:00 que agrupa solo el cuarto registro. Para analizar todo el conjunto de resultados, los registros deben agruparse en el almacén de persistencia. Esto añade complejidad y requisitos de procesamiento a la aplicación. ## Resultados completos con ventanas escalonadas Para mejorar la precisión de los registros de datos de tiempo, Kinesis Data Analytics ofrece un nuevo tipo de ventana llamada *ventanas escalonadas*. En este tipo de ventana, la ventana se abre cuando llega el primer evento que coincide con la clave de partición y no a un intervalo de tiempo fijo. La ventana se cierra en función de la antigüedad especificada, que se mide desde el momento en que se abrió la ventana. Una ventana escalonada es una ventana con restricción de tiempo distinta para cada grupo de claves de una cláusula de ventana. La aplicación agrupa cada resultado de la cláusula de ventana en su propia ventana de tiempo, en lugar de usar una sola ventana para todos los resultados. En la siguiente consulta de ventana escalonada, los registros se agrupan en ventanas por hora del evento y clave de cotización: ``` 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); ``` En el siguiente diagrama, los registros se agrupan en ventanas escalonadas por hora del evento y clave de cotización: ![\[Diagram showing event aggregation into stagger windows by event time and ticker symbol.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/stagger_1.png) El diagrama anterior tiene los siguientes eventos, que son los mismos que los que analizó la aplicación de ventana de saltos: **** | 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 | El conjunto de resultados de la aplicación de ventana escalonada tiene un aspecto similar al siguiente. **** | ROWTIME | EVENT\$1TIME | TICKER\$1SYMBOL | Recuento | | --- | --- | --- | --- | | 11:01:20 | 11:00:00 | AMZN | 3 | | 11:02:15 | 11:01:00 | AMZN | 1 | El registro devuelto agrupa los tres primeros registros de entrada. Los registros se agrupan en ventanas escalonadas de un minuto. La ventana escalonada comienza cuando la aplicación recibe el primer registro AMZN (con un `ROWTIME` de 11:00:20). Cuando finaliza la ventana escalonada de un minuto (a las 11:01:20), se escribe un registro con los resultados incluidos dentro de la ventana escalonada (en función de `ROWTIME` y `EVENT_TIME`) en la secuencia de salida. Gracias al uso de una ventana escalonada, todos los registros en los que el valor de `ROWTIME` y `EVENT_TIME` esté comprendido en una ventana de un minuto se emitirán como un único resultado. El último registro (con un `EVENT_TIME` fuera de la agregación de un minuto) se agrega por separado. Esto se debe a que `EVENT_TIME` es una de las claves de partición que se utiliza para separar los registros en conjuntos de resultados y la clave de partición `EVENT_TIME` para la primera ventana es `11:00`. La sintaxis de la ventana escalonada se define en una cláusula especial, `WINDOWED BY`. Esta cláusula se utiliza en lugar de la cláusula `GROUP BY` para streaming de agregaciones. La cláusula aparece inmediatamente detrás de la cláusula `WHERE` opcional y antes de la cláusula `HAVING`. La ventana escalonada se define en la cláusula `WINDOWED BY` y toma dos parámetros: claves de partición y duración de la ventana. Las claves de partición dividen el flujo del flujo de datos entrante y definen cuándo se abre la ventana. Una ventana escalonada se abre cuando el primer evento con una clave de partición única aparece en la secuencia. La ventana escalonada se cierra después de un periodo de tiempo fijo definido por la duración de la ventana. La sintaxis se muestra en el siguiente ejemplo de código: ``` ... FROM WHERE <... optional statements...> WINDOWED BY STAGGER( PARTITION BY RANGE INTERVAL ); ``` # Ventanas de saltos de tamaño constante (Agregados utilizando GROUP BY) Cuando una consulta en ventana procesa cada ventana de forma que no se superpongan, la ventana se denomina *ventana de saltos*. En este caso, cada registro de una secuencia en la aplicación pertenece a una ventana específica. Se procesa solo una vez (cuando la consulta procesa la ventana a la que pertenece el registro). ![\[Timeline showing non-overlapping windows processing data streams at distinct time intervals.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/window-tumbling-20.png) Por ejemplo, una consulta mediante una cláusula `GROUP BY` procesa las filas en una ventana de saltos. La secuencia de demostración en el [ejercicio de introducción](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html) recibe datos de cotizaciones de valores que se asignan a la secuencia en la aplicación `SOURCE_SQL_STREAM_001` en su aplicación. Esta secuencia tiene el siguiente esquema. ``` (TICKER_SYMBOL VARCHAR(4), SECTOR varchar(16), CHANGE REAL, PRICE REAL) ``` En el código de la aplicación, suponga que desea encontrar los precios (min, max) agregados de cada símbolo a lo largo de un periodo de un minuto. Puede utilizar la siguiente 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); ``` El ejemplo anterior es una consulta en ventana que está basada en el tiempo. La consulta agrupa los registros por valores `ROWTIME`. Para notificar cada minuto, la función `STEP` redondea hacia abajo los valores `ROWTIME` al minuto más próximo. **nota** También puede utilizar la función `FLOOR` para agrupar registros en ventanas. Sin embargo, `FLOOR` solo puede redondear los valores temporales hacia abajo a una unidad de tiempo completa (hora, minuto, segundo, etc.). Se recomienda `STEP` para agrupar los registros en ventanas de saltos, ya que puede redondear los valores hacia abajo a un intervalo arbitrario, por ejemplo, 30 segundos. Este es un ejemplo de una ventana que no se superpone (de saltos). La cláusula `GROUP BY` agrupa los registros en una ventana de un minuto y cada registro pertenece a una ventana específica (sin solapamiento). La consulta emite un registro de salida por minuto, que proporciona el precio de cotización registrado min/max en ese minuto específico. Este tipo de consulta es útil para generar informes periódicos a partir de el flujo de datos de entrada. En este ejemplo, los informes se generan cada minuto. **Para probar la consulta** 1. Configure una aplicación siguiendo el [ejercicio de introducción](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). 1. Sustituya la instrucción `SELECT` en el código de la aplicación por la consulta `SELECT` anterior. El código de la aplicación resultante se muestra a continuación: ``` 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); ``` # Ventanas deslizantes En lugar de agrupar los registros utilizando `GROUP BY`, puede definir ventana basada en tiempo o filas. Para ello, añada una cláusula `WINDOW` explícita. En este caso, como la ventana se mueve con el tiempo, Amazon Kinesis Data Analytics emite una salida cuando aparecen nuevos registros en la secuencia. Kinesis Data Analytics emite esta salida al procesar las filas en la ventana. Las ventanas pueden superponerse en este tipo de procesamiento, y un registro pueden formar parte de varias ventanas y ser procesado con cada ventana. El siguiente ejemplo ilustra una ventana deslizante. Considere una simple consulta que calcule registros en la secuencia. En este ejemplo se supone una ventana de 5 segundos. En el siguiente ejemplo de secuencia, llegan nuevos registros en el tiempo t1, t2, t6 y t7 y tres registros llegan en el tiempo 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/es_es/kinesisanalytics/latest/dev/images/sliding-10.png) Tenga en cuenta lo siguiente: + En el ejemplo se supone una ventana de 5 segundos. La ventana de 5 segundos varía de forma continua con el tiempo. + Por cada fila que introduce en una ventana, la ventana deslizante emite una fila de salida. Poco después que se inicie la aplicación, verá que la consulta emite una salida para cada nuevo registro que aparece en la secuencia, a pesar de no haya pasado todavía la ventana de 5 segundos. Por ejemplo, la consulta emite una salida cuando un registro aparece en el primer segundo y segundo segundo. Después, la consulta procesa los registros en la ventana de 5 segundos. + Las ventanas varían con el tiempo. Si se un registro anterior en la secuencia cae fuera de la ventana, la consulta no emite una salida a menos que también exista un nuevo registro en la secuencia que entre en esa ventana de 5 segundos. Imagine que la consulta empieza a ejecutarse en t0. Entonces, ocurriría lo siguiente: 1. La consulta empieza en el tiempo t0. La consulta no emite una salida (valor de recuento), porque no existen registros en ese momento. ![\[Timeline showing a stream starting at t0 with no output initially indicated.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/sliding-t0.png) 1. En el tiempo t1, un nuevo registro aparece en la secuencia y la consulta emite el valor de recuento 1. ![\[Timeline showing a stream with a record appearing at time t1, and an arrow pointing to t0.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/sliding-t1.png) 1. En el tiempo t2, otro registro aparece y la consulta emite recuento 2. ![\[Timeline showing stream events at different time points, with two vertical bars at the end.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/sliding-t2.png) 1. La ventana de 5 segundos se desliza con el tiempo: + En t3, la ventana deslizante abarca de t3 a t0 + En t4 (ventana deslizante de t4 a t0) + En t5, la ventana deslizante abarca de t5 a t0 Todas estas veces, la ventana de 5 segundos tiene los mismos registros, no hay nuevos registros. Por lo tanto, la consulta no emite ninguna salida. ![\[Timeline showing stream with multiple time points and colored rectangles representing data windows.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/sliding-t3-4-5.png) 1. En el tiempo t6, la ventana de 5 segundos es (t6 a t1). La consulta detecta un nuevo registro en t6, por lo que emite la salida 2. El registro en t1 ya no está en la ventana y no se tiene en cuenta. ![\[Timeline showing stream events at different time points with a sliding 5-second window.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/sliding-t6.png) 1. En el tiempo t7, la ventana de 5 segundos es t7 a t2. La consulta detecta un nuevo registro en t7, por lo que emite la salida 2. El registro en t2 ya no está en la ventana de 5 segundos y, por lo tanto, no se tiene en cuenta. ![\[Timeline showing stream events and time points from t0 to t7, with a 5-second window highlighted.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/sliding-t7.png) 1. En el tiempo t8, la ventana de 5 segundos es t8 a t3. La consulta detecta tres nuevos registros, y, por lo tanto, emite el recuento de registro 5. ![\[Timeline showing stream events with orange bars representing record counts at different time intervals.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/sliding-t8.png) Resumiendo, la ventana es de tamaño fijo y varía con el tiempo. La consulta emite salidas cuando aparecen nuevos registros. **nota** Le recomendamos que utilice una ventana deslizante de no más de una hora. Si utiliza una ventana más larga, la aplicación tardará mas en reiniciarse después del mantenimiento normal del sistema. Esto se debe a que los datos de origen deben leerse de la secuencia de nuevo. A continuación, se describe un ejemplo de consultas que utiliza la cláusula `WINDOW` para definir y realizar agregados de ventanas. Como las consultas no especifican `GROUP BY`, la consulta utiliza la ventana deslizante para procesar registros en la secuencia. ## Ejemplo 1: Procesar una secuencia mediante una ventana deslizante de 1 minuto Considere la secuencia de demostración en el ejercicio de introducción que rellena la secuencia en la aplicación `SOURCE_SQL_STREAM_001`. A continuación se muestra el esquema. ``` (TICKER_SYMBOL VARCHAR(4), SECTOR varchar(16), CHANGE REAL, PRICE REAL) ``` Supongamos que desea que su aplicación calcule agregados mediante una ventana deslizante de 1 minuto. Es decir, para cada nuevo registro que aparezca en la secuencia, desea que la aplicación emita una salida aplicando sumas en los registros de la anterior ventana de 1 minuto. Puede utilizar la siguiente consulta en ventana basada en el tiempo. La consulta utiliza la cláusula `WINDOW` para definir el intervalo de 1 minuto. `PARTITION BY` en la cláusula `WINDOW` agrupa los registros por valor de símbolo dentro de la ventana 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 probar la consulta** 1. Configure una aplicación siguiendo el [Ejercicio de introducción](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). 1. Sustituya la instrucción `SELECT` en el código de la aplicación por la consulta `SELECT` anterior. A continuación se muestra el código de la aplicación resultante. ``` 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); ``` ## Ejemplo 2: Consulta que aplica agregados en una ventana deslizante La siguiente consulta sobre la secuencia de demostración, devuelve el promedio del porcentaje de cambio en el precio de cada símbolo, en una ventana 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 probar la consulta** 1. Configure una aplicación siguiendo el [Ejercicio de introducción](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). 1. Sustituya la instrucción `SELECT` en el código de la aplicación por la consulta `SELECT` anterior. A continuación se muestra el código de la aplicación resultante. ``` 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); ``` ## Ejemplo 3: Consultar datos de varias ventanas deslizantes en la misma secuencia Puede escribir consultas de modo que emitan una salida en la cual cada valor de columna se calcule mediante diferentes ventanas deslizantes definidas para la misma secuencia. En el siguiente ejemplo, la consulta emite el símbolo de salida, el precio, a2 y a10. Emite una salida para los símbolos de cotización cuya media móvil de dos filas cruza la media móvil de diez filas. Los valores de columna `a2` y `a10` se derivan de ventanas deslizantes de dos y diez filas. ``` 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 probar esta consulta con la secuencia de demostración, siga el procedimiento descrito en [Ejemplo 1](#sliding-ex1). # Operaciones de streaming de datos: uniones de secuencias Puede tener varias secuencias en la aplicación en su aplicación. Puede escribir `JOIN` consultas para evaluar los datos de estas secuencias. Suponga, por ejemplo, que tiene la siguiente secuencia en la aplicación: + **OrderStream**— Recibe los pedidos de existencias que se están realizando. ``` (orderId SqlType, ticker SqlType, amount SqlType, ROWTIME TimeStamp) ``` + **TradeStream**— Recibe las operaciones bursátiles resultantes de esos pedidos. ``` (tradeId SqlType, orderId SqlType, ticker SqlType, amount SqlType, ticker SqlType, amount SqlType, ROWTIME TimeStamp) ``` Los siguientes son ejemplos de consultas `JOIN` que correlacionan datos en estas secuencias. ## Ejemplo 1: Informar sobre las órdenes que se negocian en menos de un minuto En este ejemplo, su consulta une `OrderStream` y `TradeStream`. No obstante, como solo queremos operaciones que tienen lugar en el minuto siguiente a las órdenes, la consulta define la ventana de 1 minuto para `TradeStream`. Para obtener información sobre consultas en ventana, consulte [Ventanas 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; ``` Puede definir las ventanas de forma explícita utilizando la cláusula `WINDOW` y escribiendo las consultas anteriores de la siguiente manera: ``` 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) ``` Al incluir esta consulta en el código de la aplicación, este se ejecuta de forma continua. Para cada uno de los registros que llegan en `OrderStream`, la aplicación emite una salida si hay operaciones dentro de la ventana de 1 minuto a partir del momento en que se cursó la orden. La unión en las consultas anteriores es una unión interna donde la consulta emite los registros en `OrderStream` para los que existe un registro en `TradeStream` (y viceversa). Con una unión exterior puede crear otro escenario interesante. Supongamos que desea órdenes bursátiles para las que no se han producido operaciones al cabo de un minuto de emitir la orden y también operaciones comunicadas dentro de la misma ventana, pero para otras órdenes. Este es un ejemplo de *unión exterior*. ``` 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; ```