Setelah mempertimbangkan dengan cermat, kami memutuskan untuk menghentikan Amazon Kinesis Data Analytics untuk aplikasi SQL:
1. Mulai **1 September 2025,** kami tidak akan memberikan perbaikan bug untuk Amazon Kinesis Data Analytics untuk aplikasi SQL karena kami akan memiliki dukungan terbatas untuk itu, mengingat penghentian yang akan datang.
2. Mulai **15 Oktober 2025,** Anda tidak akan dapat membuat Kinesis Data Analytics baru untuk aplikasi SQL.
3. Kami akan menghapus aplikasi Anda mulai **27 Januari 2026**. Anda tidak akan dapat memulai atau mengoperasikan Amazon Kinesis Data Analytics untuk aplikasi SQL. Support tidak akan lagi tersedia untuk Amazon Kinesis Data Analytics untuk SQL sejak saat itu. Untuk informasi selengkapnya, lihat [Amazon Kinesis Data Analytics untuk penghentian Aplikasi SQL](discontinuation.md).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Konsep SQL Streaming
Amazon Kinesis Data Analytics menerapkan standar SQL ANSI 2008 dengan ekstensi. Ekstensi ini memungkinkan Anda memproses data streaming. Topik berikut mencakup konsep-konsep SQL streaming kunci.
**Topics**
+ [Aliran dan Pompa dalam Aplikasi](streams-pumps.md)
+ [Stempel waktu dan Kolom ROWTIME](timestamps-rowtime-concepts.md)
+ [Kueri Berkelanjutan](continuous-queries-concepts.md)
+ [Kueri Jendela](windowed-sql.md)
+ [Operasi Data Streaming: Gabungan Streaming](stream-joins-concepts.md)
# Aliran dan Pompa dalam Aplikasi
Saat Anda mengonfigurasi [input aplikasi](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/how-it-works-input.html), Anda memetakan sumber streaming ke aliran dalam aplikasi yang dibuat. Data terus mengalir dari sumber streaming ke aliran dalam aplikasi. Aliran dalam aplikasi bekerja seperti tabel yang dapat Anda kueri menggunakan pernyataan SQL, tetapi ini disebut aliran karena merupakan aliran data berkelanjutan.
**catatan**
Jangan bingung antara aliran dalam aplikasi dengan aliran data Amazon Kinesis dan aliran pengiriman Firehose. Aliran dalam aplikasi hanya ada dalam konteks aplikasi Amazon Kinesis Data Analytics. Aliran data Kinesis dan aliran pengiriman Firehose ada secara independen dari aplikasi Anda. Anda dapat mengonfigurasi keduanya sebagai sumber streaming dalam konfigurasi input aplikasi Anda atau sebagai tujuan dalam konfigurasi output.
Anda juga dapat membuat lebih banyak aliran dalam aplikasi jika perlu untuk menyimpan hasil kueri menengah. Membuat aliran dalam aplikasi adalah proses dua langkah. Pertama, Anda membuat aliran dalam aplikasi, lalu Anda memompa data ke dalamnya. Misalnya, konfigurasi input aplikasi Anda membuat aliran dalam aplikasi Anda bernama `INPUTSTREAM`. Dalam contoh berikut, Anda membuat aliran lain (`TEMPSTREAM`), lalu Anda memompa data dari `INPUTSTREAM` ke dalamnya.
1. Buat aliran dalam aplikasi (`TEMPSTREAM`) dengan tiga kolom, seperti yang ditunjukkan berikut:
```
CREATE OR REPLACE STREAM "TEMPSTREAM" (
"column1" BIGINT NOT NULL,
"column2" INTEGER,
"column3" VARCHAR(64));
```
Nama-nama kolom ditentukan dalam tanda kutip, menjadikannya peka huruf besar/kecil. Untuk informasi selengkapnya, lihat [Pengidentifikasi](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-identifiers.html) di *Referensi SQL Amazon Kinesis Data Analytics*.
1. Masukkan data ke dalam aliran menggunakan pompa. Pompa adalah kueri masuk berkelanjutan yang berjalan yang memasukkan data dari satu aliran dalam aplikasi ke aliran dalam aplikasi lainnya. Pernyataan berikut membuat pompa (`SAMPLEPUMP`) dan memasukkan data ke dalam `TEMPSTREAM` dengan memilih catatan dari aliran lainnya (`INPUTSTREAM`).
```
CREATE OR REPLACE PUMP "SAMPLEPUMP" AS
INSERT INTO "TEMPSTREAM" ("column1",
"column2",
"column3")
SELECT STREAM inputcolumn1,
inputcolumn2,
inputcolumn3
FROM "INPUTSTREAM";
```
Anda dapat memasukkan beberapa penulis ke aliran dalam aplikasi, dan mungkin ada beberapa pembaca yang dipilih dari aliran. Pikirkan aliran dalam aplikasi sebagai penerapan paradigma publish/subscribe pesan. Dalam paradigma ini, baris data, termasuk waktu pembuatan dan waktu penerimaan, dapat diproses, diinterpretasikan, dan diteruskan oleh serangkaian pernyataan SQL streaming, tanpa harus disimpan dalam RDBMS tradisional.
Setelah aliran dalam aplikasi dibuat, Anda dapat melakukan kueri SQL normal.
**catatan**
Ketika Anda mengkueri aliran, sebagian besar pernyataan SQL diikat menggunakan jendela berbasis baris atau berbasis waktu. Untuk informasi selengkapnya, lihat [Kueri Jendela](windowed-sql.md).
Anda juga dapat bergabung dengan aliran. Untuk contoh bergabung dengan aliran, lihat [Operasi Data Streaming: Gabungan Streaming](stream-joins-concepts.md).
# Stempel waktu dan Kolom ROWTIME
Aliran dalam aplikasi mencakup kolom khusus yang disebut `ROWTIME`. Kolom ini menyimpan stempel waktu ketika Amazon Kinesis Data Analytics memasukkan baris di aliran dalam aplikasi pertama. `ROWTIME` mencerminkan stempel waktu tempat Amazon Kinesis Data Analytics memasukkan catatan ke aliran dalam aplikasi pertama setelah membaca dari sumber streaming. Nilai `ROWTIME` ini selanjutnya dipertahankan di seluruh aplikasi Anda.
**catatan**
Ketika Anda memompa catatan dari satu aliran dalam aplikasi ke aliran lainnya, Anda tidak perlu secara eksplisit menyalin kolom `ROWTIME`, Amazon Kinesis Data Analytics akan menyalin kolom ini untuk Anda.
Amazon Kinesis Data Analytics menjamin nilai-nilai `ROWTIME` ditingkatkan secara monoton. Anda menggunakan stempel waktu ini di kueri jendela berbasis waktu. Untuk informasi selengkapnya, lihat [Kueri Jendela](windowed-sql.md).
Anda dapat mengakses kolom ROWTIME di pernyataan `SELECT` seperti kolom lain di aliran dalam aplikasi Anda. Contoh:
```
SELECT STREAM ROWTIME,
some_col_1,
some_col_2
FROM SOURCE_SQL_STREAM_001
```
## Memahami Berbagai Waktu dalam Analitik Streaming
Selain `ROWTIME`, ada tipe waktu lain dalam aplikasi streaming waktu nyata. Ini adalah:
+ **Event time** (Waktu peristiwa) – Stempel waktu ketika peristiwa terjadi. Ini kadang-kadang juga disebut *waktu sisi klien*. Waktu ini sering kali berguna ketika digunakan dalam analitik karena merupakan waktu ketika peristiwa terjadi. Namun, banyak sumber peristiwa, seperti ponsel dan klien web, tidak memiliki jam yang dapat diandalkan, yang dapat menyebabkan waktu yang tidak akurat. Selain itu, masalah konektivitas dapat menyebabkan catatan yang muncul di aliran tidak dalam urutan yang sama dengan peristiwa yang terjadi.
+ **Ingest time** (Waktu penyerapan) – Stempel waktu ketika catatan ditambahkan ke sumber streaming. Amazon Kinesis Data Streams mencakup bidang yang disebut `APPROXIMATE_ARRIVAL_TIME` di setiap catatan yang menyediakan stempel waktu ini. Ini kadang-kadang juga disebut sebagai *waktu sisi server*. Waktu penyerapan ini sering kali mendekati waktu kejadian. Jika ada jenis keterlambatan dalam penyerapan catatan ke aliran, ini dapat menyebabkan ketidakakuratan, yang biasanya jarang terjadi. Selain itu, waktu penyerapan jarang salah, tetapi bisa terjadi karena sifat data streaming yang terdistribusi. Oleh karena itu, waktu penyerapan sebagian besar merupakan cerminan waktu peristiwa yang akurat dan berurutan.
+ **Processing time** (Waktu pemrosesan) – Stempel waktu ketika Amazon Kinesis Data Analytics memasukkan baris di aliran dalam aplikasi pertama. Amazon Kinesis Data Analytics menyediakan stempel waktu ini di kolom `ROWTIME` yang ada di setiap aliran dalam aplikasi. Waktu pemrosesan selalu meningkat secara monoton. Namun ini tidak akan akurat jika aplikasi Anda tertinggal. (Jika aplikasi tertinggal, waktu pemrosesan tidak mencerminkan waktu peristiwa secara akurat.) `ROWTIME` ini akurat dalam kaitannya dengan jam dinding, tetapi mungkin bukan waktu ketika peristiwa benar-benar terjadi.
Menggunakan setiap waktu ini dalam kueri jendela yang berbasis waktu memiliki kelebihan dan kekurangan. Sebaiknya pilih satu atau beberapa waktu ini, dan strategi untuk menangani kerugian yang relevan berdasarkan skenario kasus penggunaan Anda.
**catatan**
Jika Anda menggunakan jendela berbasis baris, waktu bukan merupakan masalah dan Anda dapat mengabaikan bagian ini.
Kami merekomendasikan strategi dua jendela yang menggunakan dua berbasis waktu, `ROWTIME` dan salah satu waktu lainnya (waktu penyerapan atau peristiwa).
+ Gunakan `ROWTIME` sebagai jendela pertama, yang mengontrol seberapa sering kueri memancarkan hasil, seperti yang ditunjukkan dalam contoh berikut. Ini tidak digunakan sebagai waktu logis.
+ Gunakan salah satu waktu lain yang merupakan waktu logis yang ingin Anda kaitkan dengan analitik Anda. Waktu ini mewakili kapan peristiwa terjadi. Pada contoh berikut, tujuan analitik adalah mengelompokkan catatan dan dan kembali menghitung dengan ticker
Keuntungan strategi ini adalah ini dapat menggunakan waktu yang mewakili kapan peristiwa terjadi. Ini dapat menangani dengan mudah ketika aplikasi Anda tertinggal atau ketika peristiwa tiba tidak sesuai urutan. Jika aplikasi tertinggal ketika membawa catatan ke aliran dalam aplikasi, catatan masih dikelompokkan berdasarkan waktu logis di jendela kedua. Kueri menggunakan `ROWTIME` untuk menjamin urutan pemrosesan. Catatan yang terlambat (stempel waktu penyerapan menunjukkan nilai sebelumnya dibandingkan dengan nilai `ROWTIME`) juga berhasil diproses.
Pertimbangkan kueri berikut terhadap aliran demo yang digunakan dalam [Latihan Memulai](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html). Kueri menggunakan klausul `GROUP BY` dan memancarkan hitungan ticker dalam jendela tumbling satu menit.
```
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);
```
Di `GROUP BY`, Anda pertama-tama mengelompokkan catatan berdasarkan `ROWTIME` di jendela satu menit, lalu dengan `APPROXIMATE_ARRIVAL_TIME`.
Nilai stempel waktu dalam hasil dibulatkan ke interval 60 detik terdekat. Hasil grup pertama yang dipancarkan oleh kueri menunjukkan catatan di menit pertama. Grup kedua hasil yang dipancarkan menunjukkan catatan di menit berikutnya berdasarkan `ROWTIME`. Catatan terakhir menunjukkan aplikasi terlambat dalam membawa catatan di aliran dalam aplikasi (ini menunjukkan nilai `ROWTIME` yang terlambat dibandingkan dengan stempel waktu penyerapan).
```
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.
```
Anda dapat menggabungkan hasil untuk hitungan akurat akhir per menit dengan mendorong hasil ke basis data hilir. Misalnya, Anda dapat mengonfigurasi output aplikasi untuk mempertahankan hasil ke aliran pengiriman Firehose yang dapat menulis ke tabel Amazon Redshift. Setelah hasil berada di tabel Amazon Redshift, Anda dapat mengkueri tabel untuk mengomputasi total jumlah grup dengan `Ticker_Symbol`. Dalam hal `XYZ`, totalnya akurat (6\$11) meskipun catatan tiba terlambat.
# Kueri Berkelanjutan
Kueri melalui aliran terus mengeksekusi data streaming. Eksekusi berkelanjutan ini memungkinkan skenario, seperti kemampuan bagi aplikasi untuk terus mengkueri aliran dan menghasilkan pemberitahuan.
Dalam latihan Memulai, Anda memiliki aliran dalam aplikasi bernama `SOURCE_SQL_STREAM_001`. Aliran ini terus menerima harga saham dari aliran demo (Kinesis data stream). Skemanya adalah sebagai berikut:
```
(TICKER_SYMBOL VARCHAR(4),
SECTOR varchar(16),
CHANGE REAL,
PRICE REAL)
```
Misalkan Anda tertarik dengan perubahan harga saham yang lebih besar dari 15 persen. Anda dapat menggunakan kueri berikut dalam kode aplikasi Anda. Kueri ini terus berjalan dan memancarkan catatan ketika perubahan harga saham yang lebih besar dari 15 persen terdeteksi.
```
SELECT STREAM TICKER_SYMBOL, PRICE
FROM "SOURCE_SQL_STREAM_001"
WHERE (ABS((CHANGE / (PRICE-CHANGE)) * 100)) > 15
```
Gunakan prosedur berikut untuk menyiapkan aplikasi Amazon Kinesis Data Analytics dan menguji kueri ini.
**Untuk menguji kueri**
1. Buat aplikasi mengikuti [Latihan Memulai](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html).
1. Ubah pernyataan `SELECT` dalam kode aplikasi dengan kueri `SELECT` sebelumnya. Kode aplikasi yang dihasilkan ditampilkan sebagai berikut:
```
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;
```
# Kueri Jendela
Kueri SQL dalam kode aplikasi Anda dijalankan secara terus-menerus melalui aliran dalam aplikasi. Aliran dalam aplikasi mewakili data tidak terbatas yang mengalir terus-menerus melalui aplikasi Anda. Oleh karena itu, untuk mendapatkan serangkaian hasil dari input yang terus diperbarui ini, Anda sering kali mengikat kueri menggunakan jendela yang didefinisikan dalam hal waktu atau baris. Ini juga disebut *SQL jendela*.
Untuk kueri jendela berbasis waktu, Anda menentukan ukuran jendela dalam hal waktu (misalnya, jendela satu menit). Ini memerlukan kolom stempel waktu di aliran dalam aplikasi Anda yang meningkat secara monoton. (Stempel waktu untuk baris baru lebih besar dari atau sama dengan baris sebelumnya.) Amazon Kinesis Data Analytics menyediakan kolom stempel waktu yang disebut `ROWTIME` untuk setiap aliran aplikasi. Anda dapat menggunakan kolom ini saat menentukan kueri berbasis waktu. Untuk aplikasi Anda, Anda dapat memilih beberapa opsi stempel waktu lainnya. Untuk informasi selengkapnya, lihat [Stempel waktu dan Kolom ROWTIME](timestamps-rowtime-concepts.md).
Untuk kueri jendela berbasis baris, Anda menentukan ukuran jendela dalam hal jumlah baris.
Anda dapat menentukan kueri untuk memproses catatan di jendela tumbling, jendela geser, atau jendela stagger, bergantung pada kebutuhan aplikasi Anda. Kinesis Data Analytics mendukung tipe jendela berikut:
+ [Jendela Stagger](stagger-window-concepts.md): Kueri yang mengumpulkan data menggunakan jendela berbasis waktu kunci yang terbuka saat data tiba. Kunci memungkinkan beberapa jendela yang tumpang tindih. Ini adalah cara yang disarankan untuk mengumpulkan data menggunakan jendela berbasis waktu, karena Windows Stagger mengurangi keterlambatan atau out-of-order data dibandingkan dengan jendela Tumbling.
+ [Jendela Tumbling](tumbling-window-concepts.md): Kueri yang menggabungkan data menggunakan jendela berbasis waktu berbeda yang membuka dan menutup secara berkala.
+ [Jendela Geser](sliding-window-concepts.md): Kueri yang terus menggabungkan data, menggunakan waktu tetap atau interval rowcount.
# Jendela Stagger
Menggunakan *jendela stagger* adalah metode jendela yang cocok untuk menganalisis grup data yang tiba pada waktu yang tidak konsisten. Ini sangat cocok untuk kasus penggunaan analitik deret waktu apa pun, seperti serangkaian penjualan terkait atau catatan log.
Misalnya, [Log Alur VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-logs-limitations) memiliki jendela tangkapan sekitar 10 menit. Namun, log alur tersebut dapat memiliki jendela tangkapan hingga 15 menit jika Anda menggabungkan data di klien. Jendela stagger cocok untuk menggabungkan log ini untuk analisis.
Jendela stagger mengatasi masalah catatan terkait yang tidak masuk ke jendela yang dibatasi waktu yang sama, seperti ketika jendela tumbling digunakan.
## Hasil Parsial dengan Jendela Tumbling
Ada batasan tertentu dengan penggunaan [Jendela Tumbling](tumbling-window-concepts.md) untuk menggabungkan keterlambatan atau out-of-order data.
Jika jendela tumbling digunakan untuk menganalisis grup data terkait waktu, catatan individu mungkin masuk ke jendela terpisah. Selanjutnya hasil parsial dari setiap jendela harus digabungkan nanti untuk menghasilkan hasil yang lengkap untuk setiap grup catatan.
Dalam kueri jendela tumbling berikut, catatan dikelompokkan ke dalam jendela berdasarkan waktu baris, waktu peristiwa, dan simbol ticker:
```
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);
```
Dalam diagram berikut, aplikasi menghitung jumlah perdagangan yang diterimanya, berdasarkan waktu perdagangan terjadi (waktu peristiwa) dengan satu menit granularitas. Aplikasi ini dapat menggunakan jendela tumbling untuk mengelompokkan data berdasarkan waktu baris dan waktu peristiwa. Aplikasi menerima empat catatan yang semuanya tiba dalam satu menit. Ini mengelompokkan catatan berdasarkan waktu baris, waktu peristiwa, dan simbol ticker. Karena beberapa catatan tiba setelah jendela tumbling pertama berakhir, semua catatan tidak masuk dalam jendela tumbling satu menit yang sama.
![\[Tumbling windows diagram showing data grouping by row time, event time, and ticker symbol over two minutes.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/stagger_0.png)
Diagram sebelumnya memiliki peristiwa berikut.
****
| 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 |
Hasil yang ditetapkan dari aplikasi jendela tumbling terlihat sama dengan yang berikut ini.
****
| 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 |
Dalam serangkaian hasil sebelumnya, tiga hasil dikembalikan:
+ Catatan dengan `ROWTIME` dari 11:01:00 yang menggabungkan dua catatan pertama.
+ Catatan pada 11:02:00 yang hanya menggabungkan catatan ketiga. Catatan ini memiliki `ROWTIME` dalam jendela kedua, tetapi `EVENT_TIME` dalam jendela pertama.
+ Catatan pada 11:02:00 yang hanya menggabungkan catatan keempat.
Untuk menganalisis serangkaian hasil yang lengkap, catatan harus digabungkan di penyimpanan yang persisten. Hal ini menambah kompleksitas dan persyaratan pemrosesan untuk aplikasi.
## Lengkapi Hasil dengan Jendela Stagger
Untuk meningkatkan akurasi analisis catatan data terkait waktu, Kinesis Data Analytics menawarkan tipe jendela baru yang disebut *jendela stagger*. Dalam tipe jendela ini, jendela terbuka ketika peristiwa pertama yang cocok dengan kunci partisi tiba, dan bukan pada interval waktu yang tetap. Jendela ditutup berdasarkan masa yang ditentukan, yang diukur dari waktu ketika jendela dibuka.
Jendela stagger adalah jendela terbatas waktu terpisah untuk setiap pengelompokan kunci dalam klausa jendela. Aplikasi menggabungkan setiap hasil dari klausa jendela dalam jendela waktunya sendiri, daripada menggunakan satu jendela untuk semua hasil.
Dalam kueri jendela stagger berikut, catatan dikelompokkan ke dalam jendela berdasarkan waktu peristiwa dan simbol ticker:
```
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);
```
Dalam diagram berikut, peristiwa dikumpulkan berdasarkan waktu peristiwa dan simbol ticker ke jendela stagger.
![\[Diagram showing event aggregation into stagger windows by event time and ticker symbol.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/stagger_1.png)
Diagram sebelumnya memiliki peristiwa berikut, yang merupakan peristiwa yang sama seperti aplikasi jendela tumbling yang dianalisis:
****
| 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 |
Hasil yang ditetapkan dari aplikasi jendela stagger terlihat sama dengan yang berikut ini.
****
| ROWTIME | EVENT\$1TIME | TICKER\$1SYMBOL | Count |
| --- | --- | --- | --- |
| 11:01:20 | 11:00:00 | AMZN | 3 |
| 11:02:15 | 11:01:00 | AMZN | 1 |
Catatan yang dikembalikan menggabungkan tiga catatan input pertama. Catatan dikelompokkan oleh jendela stagger satu menit. Jendela stagger dimulai ketika aplikasi menerima catatan AMZN pertama (dengan `ROWTIME` dari 11:00:20). Ketika jendela stagger 1 menit berakhir (pada 11:01:20), catatan dengan hasil yang masuk dalam jendela stagger (berdasarkan `ROWTIME` dan `EVENT_TIME`) ditulis ke aliran output. Menggunakan jendela stagger, semua catatan dengan `ROWTIME` dan `EVENT_TIME` dalam jendela satu menit dipancarkan dalam satu hasil.
Catatan terakhir (dengan `EVENT_TIME` di luar agregasi satu menit) digabungkan secara terpisah. Ini karena `EVENT_TIME` adalah salah satu kunci partisi yang digunakan untuk memisahkan catatan ke serangkaian hasil, dan kunci partisi `EVENT_TIME` untuk jendela pertama adalah `11:00`.
Sintaksis untuk jendela stagger didefinisikan dalam klausa khusus, `WINDOWED BY`. Klausa ini digunakan sebagai pengganti klausa `GROUP BY` untuk agregasi streaming. Klausa muncul segera setelah klausa `WHERE` opsional dan sebelum klausa `HAVING`.
Jendela stagger didefinisikan dalam klausa `WINDOWED BY` dan mengambil dua parameter: kunci partisi dan panjang jendela. Kunci partisi membuat partisi aliran data yang masuk dan menentukan kapan jendela terbuka. Jendela stagger terbuka saat peristiwa pertama dengan kunci partisi unik muncul di aliran. Jendela stagger tertutup setelah periode waktu yang ditetapkan oleh panjang jendela. Sintaksis ditampilkan dalam contoh kode berikut:
```
...
FROM
WHERE <... optional statements...>
WINDOWED BY STAGGER(
PARTITION BY
RANGE INTERVAL
);
```
# Jendela Tumbling (Agregasi Menggunakan GROUP BY)
Ketika kueri jendela memproses setiap jendela dengan cara yang tidak tumpang tindih, jendela disebut sebagai *jendela tumbling*. Dalam hal ini, setiap catatan di aliran dalam aplikasi termasuk dalam jendela tertentu. Catatan hanya diproses sekali (ketika kueri memproses jendela tempat catatan berada).
![\[Timeline showing non-overlapping windows processing data streams at distinct time intervals.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/window-tumbling-20.png)
Misalnya, kueri agregasi yang menggunakan klausa `GROUP BY` memproses baris dalam jendela tumbling. Aliran demo dalam [latihan memulai](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html) menerima data harga saham yang dipetakan ke aliran dalam aplikasi `SOURCE_SQL_STREAM_001` dalam aplikasi Anda. Aliran ini memiliki skema berikut.
```
(TICKER_SYMBOL VARCHAR(4),
SECTOR varchar(16),
CHANGE REAL,
PRICE REAL)
```
Dalam kode aplikasi Anda, misalkan Anda ingin menemukan harga agregat (min, max) untuk setiap ticker selama jendela satu menit. Anda dapat menggunakan kueri berikut.
```
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);
```
Sebelumnya adalah contoh kueri jendela yang berbasis waktu. Kueri mengelompokkan catatan berdasarkan nilai `ROWTIME`. Untuk pelaporan per menit, fungsi `STEP` membulatkan nilai `ROWTIME` ke menit terdekat.
**catatan**
Anda juga dapat menggunakan fungsi `FLOOR` untuk mengelompokkan catatan ke jendela. Namun, `FLOOR` hanya dapat membulatkan nilai waktu ke unit waktu keseluruhan (jam, menit, detik, dan sebagainya). `STEP` direkomendasikan untuk mengelompokkan catatan ke jendela tumbling karena dapat membulatkan nilai ke interval arbitrer, misalnya, 30 detik.
Kueri ini adalah contoh jendela non-tumpang tindih (tumbling). Klausa `GROUP BY` mengelompokkan catatan dalam jendela satu menit, dan setiap catatan termasuk ke jendela tertentu (tidak tumpang tindih). Kueri memancarkan satu catatan keluaran per menit, memberikan harga min/max ticker yang dicatat pada menit tertentu. Tipe kueri berguna untuk membuat laporan berkala dari aliran data input. Dalam contoh ini, laporan dihasilkan setiap menit.
**Untuk menguji kueri**
1. Siapkan aplikasi dengan mengikuti [latihan memulai](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html).
1. Ubah pernyataan `SELECT` dalam kode aplikasi menggunakan kueri `SELECT` sebelumnya. Kode aplikasi yang dihasilkan ditampilkan sebagai berikut:
```
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);
```
# Jendela Geser
Alih-alih mengelompokkan catatan menggunakan `GROUP BY`, Anda dapat menentukan jendela berbasis waktu atau berbasis baris. Anda melakukan ini dengan menambahkan klausul `WINDOW` eksplisit.
Dalam kasus ini, saat jendela meluncur seiring waktu, Amazon Kinesis Data Analytics memancarkan output saat catatan baru muncul di aliran. Kinesis Data Analytics memancarkan output ini dengan memproses baris di jendela. Windows dapat tumpang tindih dalam tipe pemrosesan ini, dan catatan dapat menjadi bagian dari beberapa jendela dan diproses dengan setiap jendela. Contoh berikut menggambarkan jendela geser.
Pertimbangkan kueri sederhana yang menghitung catatan di aliran. Contoh ini mengasumsikan jendela 5 detik. Dalam contoh aliran berikut, catatan baru tiba pada waktu t1, t2, t6, dan t7, serta tiga catatan tiba pada waktu t8 detik.
![\[Timeline showing record arrivals at t1, t2, t6, t7, and multiple at t8 within a 5-second window.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/sliding-10.png)
Ingatlah hal-hal berikut ini:
+ Contoh mengasumsikan jendela 5 detik. Jendela 5 detik terus meluncur seiring waktu.
+ Untuk setiap baris yang memasuki jendela, baris output dipancarkan oleh jendela geser. Segera setelah aplikasi dimulai, Anda melihat kueri memancarkan output untuk setiap catatan baru yang muncul di aliran, meskipun jendela 5 detik belum diteruskan. Sebagai contoh, kueri memancarkan output ketika catatan muncul di detik pertama dan detik kedua. Selanjutnya, kueri memproses catatan di jendela 5 detik.
+ Jendela meluncur seiring waktu. Jika catatan lama di aliran masuk ke jendela, kueri tidak memancarkan output kecuali juga ada catatan baru di aliran yang masuk dalam jendela 5 detik.
Misalkan kueri mulai mengeksekusi di t0. Kemudian hal berikut terjadi:
1. Pada waktu t0, kueri dimulai. Kueri tidak memancarkan output (nilai jumlah) karena saat ini tidak ada catatan.
![\[Timeline showing a stream starting at t0 with no output initially indicated.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/sliding-t0.png)
1. Pada waktu t1, catatan baru muncul di aliran, dan kueri memancarkan nilai hitungan 1.
![\[Timeline showing a stream with a record appearing at time t1, and an arrow pointing to t0.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/sliding-t1.png)
1. Pada waktu t2, catatan baru muncul di aliran, dan kueri memancarkan hitungan 2.
![\[Timeline showing stream events at different time points, with two vertical bars at the end.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/sliding-t2.png)
1. Jendela 5 detik meluncur seiring waktu:
+ Di t3, jendela geser t3 ke t0
+ Di t4 (jendela geser t4 ke t0)
+ Di t5, jendela geser t5–t0
Pada semua waktu ini, jendela 5 detik memiliki catatan yang sama—tidak ada catatan baru. Oleh karena itu, kueri tidak memancarkan output apa pun.
![\[Timeline showing stream with multiple time points and colored rectangles representing data windows.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/sliding-t3-4-5.png)
1. Pada waktu t6, jendela 5 detik adalah (t6 ke t1). Kueri mendeteksi satu catatan baru di t6 sehingga memancarkan output 2. Catatan di t1 tidak lagi berada di jendela dan tidak masuk hitungan.
![\[Timeline showing stream events at different time points with a sliding 5-second window.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/sliding-t6.png)
1. Pada waktu t7, jendela 5 detik adalah t7 ke t2. Kueri mendeteksi satu catatan baru di t7 sehingga memancarkan output 2. Catatan di t2 tidak lagi di jendela 5 detik, dan oleh karena itu tidak dihitung.
![\[Timeline showing stream events and time points from t0 to t7, with a 5-second window highlighted.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/sliding-t7.png)
1. Pada waktu t8, jendela 5 detik adalah t8 ke t3. Kueri mendeteksi tiga catatan baru, dan oleh karena itu memancarkan catatan hitungan 5.
![\[Timeline showing stream events with orange bars representing record counts at different time intervals.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/sliding-t8.png)
Singkatnya, jendela adalah ukuran tetap dan meluncur seiring waktu. Kueri memancarkan output ketika catatan baru muncul.
**catatan**
Sebaiknya gunakan jendela geser tidak lebih dari satu jam. Jika Anda menggunakan jendela yang lebih lama, aplikasi memerlukan waktu lebih lama untuk memulai ulang setelah pemeliharaan sistem reguler. Hal ini karena sumber data harus dibaca kembali dari aliran.
Contoh kueri berikut menggunakan klausa `WINDOW` untuk menentukan jendela dan melakukan agregat. Karena kueri tidak menentukan `GROUP BY`, kueri menggunakan pendekatan jendela geser untuk memproses catatan di aliran.
## Contoh 1: Proses Streaming menggunakan Jendela Geser 1 Menit
Pertimbangkan aliran demo dalam latihan Memulai yang mengisi aliran dalam aplikasi, `SOURCE_SQL_STREAM_001`. Berikut ini adalah skemanya.
```
(TICKER_SYMBOL VARCHAR(4),
SECTOR varchar(16),
CHANGE REAL,
PRICE REAL)
```
Misalkan Anda ingin aplikasi Anda menghitung agregat menggunakan jendela geser 1 menit. Yaitu, untuk setiap catatan baru yang muncul di aliran, Anda ingin aplikasi memancarkan output dengan menerapkan agregat pada catatan di jendela 1 menit sebelumnya.
Anda dapat menggunakan kueri jendela berbasis waktu berikut. Kueri menggunakan klausul `WINDOW` untuk menentukan interval rentang 1 menit. `PARTITION BY` di klausa `WINDOW` mengelompokkan catatan berdasarkan nilai ticker dalam jendela geser.
```
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);
```
**Untuk menguji kueri**
1. Siapkan aplikasi dengan mengikuti [Latihan Memulai](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html).
1. Ubah pernyataan `SELECT` dalam kode aplikasi dengan kueri `SELECT` sebelumnya. Kode aplikasi yang dihasilkan adalah sebagai berikut.
```
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);
```
## Contoh 2: Kueri yang Menerapkan Agregat di Jendela Geser
Kueri pada aliran demo berikut mengembalikan rata-rata perubahan persen dalam harga setiap ticker dalam jendela 10 detik.
```
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);
```
**Untuk menguji kueri**
1. Siapkan aplikasi dengan mengikuti [Latihan Memulai](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html).
1. Ubah pernyataan `SELECT` dalam kode aplikasi dengan kueri `SELECT` sebelumnya. Kode aplikasi yang dihasilkan adalah sebagai berikut.
```
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);
```
## Contoh 3: Kueri Data dari Beberapa Jendela Geser di Aliran yang Sama
Anda dapat menulis kueri untuk memancarkan output tempat setiap nilai kolom dihitung menggunakan jendela geser yang berbeda yang didefinisikan melalui aliran yang sama.
Pada contoh berikut, kueri memancarkan ticker output, harga, a2, dan a10. Ini memancarkan output untuk simbol ticker yang rata-rata pergerakan dua barisnya melintasi rata-rata pergerakan sepuluh baris. Nilai kolom `a2` dan `a10` diturunkan dari jendela geser dua baris dan sepuluh baris.
```
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);
```
Untuk menguji kueri ini terhadap aliran demo, ikuti prosedur pengujian yang dijelaskan dalam [Contoh 1](#sliding-ex1).
# Operasi Data Streaming: Gabungan Streaming
Anda dapat memiliki beberapa aliran dalam aplikasi di aplikasi Anda. Anda dapat menulis kueri `JOIN` untuk menghubungkan data yang tiba di aliran ini. Misalnya, anggap Anda memiliki aliran dalam aplikasi berikut:
+ **OrderStream**— Menerima pesanan stok yang ditempatkan.
```
(orderId SqlType, ticker SqlType, amount SqlType, ROWTIME TimeStamp)
```
+ **TradeStream**— Menerima perdagangan saham yang dihasilkan untuk pesanan tersebut.
```
(tradeId SqlType, orderId SqlType, ticker SqlType, amount SqlType, ticker SqlType, amount SqlType, ROWTIME TimeStamp)
```
Berikut ini adalah contoh kueri `JOIN` yang menghubungkan data di aliran ini.
## Contoh 1: Laporkan Pesanan Jika Ada Perdagangan dalam Satu Menit Setelah Pesanan Ditempatkan
Dalam contoh ini, kueri Anda bergabung dengan `OrderStream` dan `TradeStream`. Namun, karena kita hanya menginginkan perdagangan yang ditempatkan satu menit setelah perintah, kueri mendefinisikan jendela 1 menit melalui `TradeStream`. Untuk informasi tentang kueri jendela, lihat [Jendela Geser](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;
```
Anda dapat menentukan jendela secara eksplisit menggunakan klausa `WINDOW` dan menulis kueri sebelumnya sebagai berikut:
```
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)
```
Ketika Anda menyertakan kueri ini dalam kode aplikasi Anda, kode aplikasi berjalan terus menerus. Untuk setiap catatan yang tiba di `OrderStream`, aplikasi memancarkan output jika ada perdagangan dalam jendela 1 menit setelah pesanan ditempatkan.
Gabung dengan kueri sebelumnya adalah gabungan dalam tempat kueri memancarkan catatan di `OrderStream` ketika ada catatan yang cocok di `TradeStream` (dan sebaliknya). Dengan menggunakan gabuangan luar, Anda dapat membuat skenario menarik lainnya. Misalkan Anda menginginkan pesanan saham yang tidak ada perdagangan selama satu menit setelah pesanan saham ditempatkan, dan perdagangan yang dilaporkan dalam jendela yang sama, tetapi untuk beberapa pesanan lainnya. Ini adalah contoh *gabungan luar*.
```
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;
```