Amazon Redshift tidak akan lagi mendukung pembuatan Python UDFs baru mulai Patch 198. Python yang ada UDFs akan terus berfungsi hingga 30 Juni 2026. Untuk informasi lebih lanjut, lihat [posting blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Jalankan perintah untuk mendefinisikan dan menggunakan database di gudang data Anda
Baik gudang data Redshift Tanpa Server dan gudang data yang disediakan Amazon Redshift berisi database. Setelah meluncurkan gudang data, Anda dapat mengelola sebagian besar tindakan database menggunakan perintah SQL. Dengan beberapa pengecualian, fungsionalitas dan sintaks SQL sama untuk semua database Amazon Redshift. Untuk detail perintah SQL yang tersedia dengan Amazon Redshift, [lihat perintah SQL](https://docs.aws.amazon.com/redshift/latest/dg/c_SQL_commands.html) di Panduan Pengembang *Database Amazon Redshift*.
Saat Anda membuat gudang data, di sebagian besar skenario, Amazon Redshift juga membuat database default`dev`. Setelah Anda terhubung ke `dev` database, Anda dapat membuat database lain.
Bagian berikut berjalan melalui tugas-tugas database umum saat bekerja dengan database Amazon Redshift. Tugas dimulai dengan membuat database dan jika Anda melanjutkan ke tugas terakhir Anda dapat menghapus semua sumber daya yang Anda buat dengan menjatuhkan database.
Contoh di bagian ini mengasumsikan hal berikut:
+ Anda telah membuat gudang data Amazon Redshift.
+ Anda telah membuat koneksi ke gudang data dari alat klien SQL Anda, seperti editor kueri Amazon Redshift v2. Untuk informasi selengkapnya tentang editor kueri v2, lihat [Menanyakan database menggunakan editor kueri Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) v2 di Panduan Manajemen *Amazon Redshift*.
**Topics**
+ [Menghubungkan ke gudang data Amazon Redshift](#connection)
+ [Buat database](t_creating_database.md)
+ [Buat pengguna](t_adding_redshift_user_cmd.md)
+ [Buat skema](t_creating_schema.md)
+ [Membuat tabel](t_creating_table.md)
+ [Memuat data](cm-dev-t-load-sample-data.md)
+ [Kueri tabel dan tampilan sistem](t_querying_redshift_system_tables.md)
+ [Batalkan kueri](cancel_query.md)
## Menghubungkan ke gudang data Amazon Redshift
Untuk terhubung ke cluster Amazon Redshift, dari halaman Clusters konsol Amazon Redshift, perluas **cluster** Connect **to Amazon Redshift dan lakukan salah satu hal berikut**:
+ Pilih **Data kueri** untuk menggunakan editor kueri v2 untuk menjalankan kueri pada database yang dihosting oleh cluster Amazon Redshift Anda. Setelah membuat cluster Anda, Anda dapat langsung menjalankan kueri dengan menggunakan editor kueri v2.
Untuk informasi selengkapnya, lihat [Menanyakan database menggunakan editor kueri Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) v2 di Panduan Manajemen *Pergeseran Merah Amazon*.
+ Di **Bekerja dengan alat klien Anda**, pilih klaster Anda dan sambungkan ke Amazon Redshift dari alat klien Anda menggunakan driver JDBC atau ODBC dengan menyalin URL driver JDBC atau ODBC. Gunakan URL ini dari komputer klien atau instance Anda. Kode aplikasi Anda untuk menggunakan operasi API akses data JDBC atau ODBC, atau gunakan alat klien SQL yang mendukung JDBC atau ODBC.
Untuk informasi selengkapnya tentang cara menemukan string koneksi cluster, lihat [Menemukan string koneksi cluster Anda](https://docs.aws.amazon.com/redshift/latest/mgmt/configuring-connections.html#connecting-drivers.html).
+ Jika alat klien SQL Anda memerlukan driver, Anda dapat **Memilih driver JDBC atau ODBC Anda untuk mengunduh driver** khusus sistem operasi untuk terhubung ke Amazon Redshift dari alat klien Anda.
Untuk informasi selengkapnya tentang cara menginstal driver yang sesuai untuk klien SQL Anda, lihat [Mengonfigurasi koneksi driver JDBC versi 2.2](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-install.html).
Untuk informasi selengkapnya tentang cara mengonfigurasi koneksi ODBC, lihat [Mengonfigurasi koneksi ODBC](https://docs.aws.amazon.com/redshift/latest/mgmt/configure-odbc-connection.html).
Untuk terhubung ke gudang data Redshift Tanpa Server, dari halaman **dasbor Tanpa Server** konsol Amazon Redshift, lakukan salah satu hal berikut:
+ Gunakan editor kueri Amazon Redshift v2 untuk menjalankan kueri pada database yang dihosting oleh gudang data Redshift Tanpa Server Anda. Setelah membuat gudang data Anda, Anda dapat langsung menjalankan kueri dengan menggunakan editor kueri v2.
Untuk informasi selengkapnya, lihat [Menanyakan database menggunakan editor kueri Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html).
+ Sambungkan ke Amazon Redshift dari alat klien Anda menggunakan driver JDBC atau ODBC dengan menyalin URL driver JDBC atau ODBC.
Untuk bekerja dengan data di gudang data Anda, Anda memerlukan driver JDBC atau ODBC untuk konektivitas dari komputer klien atau instance Anda. Kode aplikasi Anda untuk menggunakan operasi API akses data JDBC atau ODBC, atau gunakan alat klien SQL yang mendukung JDBC atau ODBC.
*Untuk informasi selengkapnya tentang cara menemukan string koneksi, lihat [Menyambung ke Redshift Tanpa Server](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-connecting) di Panduan Manajemen Pergeseran Merah Amazon.*
# Buat database
Setelah Anda memverifikasi bahwa gudang data Anda aktif dan berjalan, Anda dapat membuat database. Database ini adalah tempat Anda benar-benar membuat tabel, memuat data, dan menjalankan kueri. Gudang data dapat meng-host beberapa database. Misalnya, Anda dapat memiliki database untuk data penjualan bernama `SALESDB` dan database untuk data pesanan yang disebutkan `ORDERSDB` di gudang data yang sama.
Untuk membuat database bernama**SALESDB**, jalankan perintah berikut di alat klien SQL Anda.
```
CREATE DATABASE salesdb;
```
**catatan**
Setelah menjalankan perintah, pastikan untuk menyegarkan daftar alat klien SQL Anda dari objek di gudang data Anda untuk melihat yang baru`salesdb`.
Untuk latihan ini, terima defaultnya. Untuk informasi tentang opsi perintah lainnya, lihat [MEMBUAT DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE) di Panduan *Pengembang Database Amazon Redshift*. Untuk menghapus database dan isinya, lihat [DROP DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_DATABASE) di Panduan *Pengembang Database Amazon Redshift*.
Setelah Anda membuat database SALESDB, Anda dapat terhubung ke database baru dari klien SQL Anda. Gunakan parameter koneksi yang sama seperti yang Anda gunakan untuk koneksi Anda saat ini, tetapi ubah nama database menjadi`SALESDB`.
# Buat pengguna
Secara default, hanya pengguna admin yang Anda buat saat meluncurkan gudang data yang memiliki akses ke database default di gudang data. Untuk memberikan akses kepada pengguna lain, buat satu atau beberapa akun. Akun pengguna database bersifat global di semua database dalam gudang data, dan bukan per database individu.
Gunakan perintah CREATE USER untuk membuat pengguna baru. Saat Anda membuat pengguna baru, Anda menentukan nama pengguna baru dan kata sandi. Kami menyarankan Anda menentukan kata sandi untuk pengguna. Itu harus memiliki 8-64 karakter, dan harus mencakup setidaknya satu huruf besar, satu huruf kecil, dan satu angka.
Misalnya, untuk membuat pengguna bernama **GUEST** dengan kata sandi**ABCd4321**, jalankan perintah berikut.
```
CREATE USER GUEST PASSWORD 'ABCd4321';
```
Untuk terhubung ke `SALESDB` database sebagai `GUEST` pengguna, gunakan kata sandi yang sama saat Anda membuat pengguna, seperti`ABCd4321`.
Untuk informasi tentang opsi perintah lainnya, lihat [MEMBUAT PENGGUNA di Panduan](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) *Pengembang Database Amazon Redshift*.
# Buat skema
Setelah Anda membuat database baru, Anda dapat membuat skema baru dalam database saat ini. *Skema* adalah namespace yang berisi objek database bernama seperti tabel, tampilan, dan fungsi yang ditentukan pengguna (). UDFs Sebuah database dapat berisi satu atau beberapa skema, dan setiap skema hanya milik satu database. Dua skema dapat memiliki objek berbeda yang memiliki nama yang sama.
Anda dapat membuat beberapa skema dalam database yang sama untuk mengatur data dengan cara yang Anda inginkan atau untuk mengelompokkan data Anda secara fungsional. Misalnya, Anda dapat membuat skema untuk menyimpan semua data pementasan dan skema lain untuk menyimpan semua tabel pelaporan. Anda juga dapat membuat skema yang berbeda untuk menyimpan data yang relevan dengan grup bisnis yang berbeda yang berada dalam database yang sama. Setiap skema dapat menyimpan objek database yang berbeda, seperti tabel, tampilan, dan fungsi yang ditentukan pengguna (). UDFs Selain itu, Anda dapat membuat skema dengan klausa OTORISASI. Klausul ini memberikan kepemilikan kepada pengguna tertentu atau menetapkan kuota pada jumlah maksimum ruang disk yang dapat digunakan skema tertentu.
Amazon Redshift secara otomatis membuat skema yang dipanggil `public` untuk setiap database baru. Bila Anda tidak menentukan nama skema saat membuat objek database, objek masuk ke `public` skema.
Untuk mengakses objek dalam skema, kualifikasi objek dengan menggunakan notasi. `schema_name.table_name` Nama skema yang memenuhi syarat terdiri dari nama skema dan nama tabel yang dipisahkan oleh titik. Misalnya, Anda mungkin memiliki `sales` skema yang memiliki `price` tabel dan `inventory` skema yang juga memiliki `price` tabel. Ketika Anda merujuk ke `price` tabel, Anda harus memenuhi syarat sebagai `sales.price` atau`inventory.price`.
Contoh berikut membuat skema bernama **SALES** untuk pengguna`GUEST`.
```
CREATE SCHEMA SALES AUTHORIZATION GUEST;
```
Untuk informasi tentang opsi perintah lainnya, lihat [MEMBUAT SKEMA di Panduan](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_SCHEMA.html) Pengembang *Database Amazon Redshift*.
Untuk melihat daftar skema dalam database Anda, jalankan perintah berikut.
```
select * from pg_namespace;
```
Outputnya akan terlihat serupa dengan yang berikut ini:
```
nspname | nspowner | nspacl
----------------------+----------+--------------------------
sales | 100 |
pg_toast | 1 |
pg_internal | 1 |
catalog_history | 1 |
pg_temp_1 | 1 |
pg_catalog | 1 | {rdsdb=UC/rdsdb,=U/rdsdb}
public | 1 | {rdsdb=UC/rdsdb,=U/rdsdb}
information_schema | 1 | {rdsdb=UC/rdsdb,=U/rdsdb}
```
Untuk informasi selengkapnya tentang cara menanyakan tabel katalog, lihat [Menanyakan tabel katalog di Panduan Pengembang](https://docs.aws.amazon.com/redshift/latest/dg/c_join_PG.html) *Database Amazon Redshift*.
Gunakan pernyataan GRANT untuk memberikan izin kepada pengguna untuk skema.
Contoh berikut memberikan hak istimewa kepada `GUEST` pengguna untuk memilih data dari semua tabel atau tampilan dalam `SALES` skema menggunakan pernyataan SELECT.
```
GRANT SELECT ON ALL TABLES IN SCHEMA SALES TO GUEST;
```
Contoh berikut memberikan semua hak istimewa yang tersedia sekaligus kepada pengguna. `GUEST`
```
GRANT ALL ON SCHEMA SALES TO GUEST;
```
# Membuat tabel
Setelah Anda membuat database baru, buat tabel untuk menyimpan data Anda. Tentukan informasi kolom saat Anda membuat tabel.
Misalnya, untuk membuat tabel bernama**DEMO**, jalankan perintah berikut.
```
CREATE TABLE Demo (
PersonID int,
City varchar (255)
);
```
Secara default, objek database baru, seperti tabel, dibuat dalam skema default bernama `public` dibuat selama pembuatan gudang data. Anda dapat menggunakan skema lain untuk membuat objek database. Untuk informasi selengkapnya tentang skema, lihat [Mengelola keamanan database](https://docs.aws.amazon.com/redshift/latest/dg/r_Database_objects.html) di Panduan Pengembang *Database Amazon Redshift*.
Anda juga dapat membuat tabel menggunakan `schema_name.object_name` notasi untuk membuat tabel dalam `SALES` skema.
```
CREATE TABLE SALES.DEMO (
PersonID int,
City varchar (255)
);
```
Untuk melihat dan memeriksa skema dan tabelnya, Anda dapat menggunakan editor kueri Amazon Redshift v2. Atau Anda dapat melihat daftar tabel dalam skema menggunakan tampilan sistem. Untuk informasi selengkapnya, lihat [Kueri tabel dan tampilan sistem](t_querying_redshift_system_tables.md).
`sortkey`Kolom `encoding``distkey`,, dan digunakan oleh Amazon Redshift untuk pemrosesan paralel. Untuk informasi selengkapnya tentang mendesain tabel yang menggabungkan elemen-elemen ini, lihat [Praktik terbaik Amazon Redshift untuk mendesain](https://docs.aws.amazon.com/redshift/latest/dg/c_designing-tables-best-practices.html) tabel.
## Masukkan baris data ke dalam tabel
Setelah Anda membuat tabel, masukkan baris data ke dalam tabel itu.
**catatan**
Perintah [INSERT](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html) menyisipkan baris ke dalam tabel. Untuk beban massal standar, gunakan perintah [COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html). Untuk informasi selengkapnya, lihat [Menggunakan perintah COPY untuk memuat data](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-copy.html).
Misalnya, untuk memasukkan nilai ke dalam `DEMO` tabel, jalankan perintah berikut.
```
INSERT INTO DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
Untuk menyisipkan data ke dalam tabel yang ada dalam skema tertentu, jalankan perintah berikut.
```
INSERT INTO SALES.DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
## Pilih data dari tabel
Setelah Anda membuat tabel dan mengisinya dengan data, gunakan pernyataan SELECT untuk menampilkan data yang terkandung dalam tabel. Pernyataan SELECT \$1 mengembalikan semua nama kolom dan nilai baris untuk semua data dalam tabel. Menggunakan SELECT adalah cara yang baik untuk memverifikasi bahwa data yang baru ditambahkan dimasukkan dengan benar ke dalam tabel.
Untuk melihat data yang Anda masukkan dalam **DEMO** tabel, jalankan perintah berikut.
```
SELECT * from DEMO;
```
Hasilnya akan terlihat seperti berikut ini.
```
personid | city
----------+-----------
781 | San Jose
990 | Palo Alto
(2 rows)
```
Untuk informasi selengkapnya tentang menggunakan pernyataan SELECT untuk menanyakan tabel, lihat [SELECT](https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_synopsis.html).
# Memuat data
Banyak contoh dalam panduan ini menggunakan kumpulan data sampel TICKIT. Anda dapat mengunduh file [tickitdb.zip](samples/tickitdb.zip), yang berisi file data sampel individual. Anda kemudian dapat mengunggah data sampel ke bucket Amazon S3 Anda sendiri.
Untuk memuat data sampel untuk database Anda, buat tabel terlebih dahulu. Kemudian gunakan perintah COPY untuk memuat tabel dengan data sampel yang disimpan dalam bucket Amazon S3. Untuk langkah-langkah untuk membuat tabel dan memuat data sampel, lihat[Langkah 4: Muat data dari Amazon S3 ke Amazon Redshift](new-user.md#rs-gsg-create-sample-db).
# Kueri tabel dan tampilan sistem
Selain tabel yang Anda buat, gudang data Anda berisi sejumlah tabel dan tampilan sistem. Tabel dan tampilan ini berisi informasi tentang instalasi Anda dan berbagai kueri dan proses yang berjalan pada sistem. Anda dapat menanyakan tabel dan tampilan sistem ini untuk mengumpulkan informasi tentang database Anda. Untuk informasi selengkapnya, lihat [Referensi tabel dan tampilan sistem](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html) di Panduan *Pengembang Database Amazon Redshift*. Deskripsi untuk setiap tabel atau tampilan menunjukkan apakah tabel terlihat oleh semua pengguna atau hanya untuk pengguna super. Masuk sebagai pengguna super untuk menanyakan tabel yang hanya terlihat oleh pengguna super.
## Melihat daftar nama tabel
Untuk melihat daftar semua tabel dalam skema, Anda dapat menanyakan tabel katalog sistem PG\$1TABLE\$1DEF. Anda dapat terlebih dahulu memeriksa pengaturan untuk`search_path`.
```
SHOW search_path;
```
Hasilnya akan terlihat mirip dengan yang berikut ini,
```
search_path
---------------
$user, public
```
Contoh berikut menambahkan `SALES` skema ke jalur pencarian dan menunjukkan semua tabel dalam `SALES` skema.
```
set search_path to '$user', 'public', 'sales';
SHOW search_path;
search_path
------------------------
"$user", public, sales
select * from pg_table_def where schemaname = 'sales';
schemaname | tablename | column | type | encoding | distkey | sortkey | notnull
------------+-----------+----------+------------------------+----------+---------+---------+---------
sales | demo | personid | integer | az64 | f | 0 | f
sales | demo | city | character varying(255) | lzo | f | 0 | f
```
Contoh berikut menunjukkan daftar semua tabel yang disebut `DEMO` dalam semua skema pada database saat ini.
```
set search_path to '$user', 'public', 'sales';
select * from pg_table_def where tablename = 'demo';
schemaname | tablename | column | type | encoding | distkey | sortkey | notnull
------------+-----------+----------+------------------------+----------+---------+---------+---------
public | demo | personid | integer | az64 | f | 0 | f
public | demo | city | character varying(255) | lzo | f | 0 | f
sales | demo | personid | integer | az64 | f | 0 | f
sales | demo | city | character varying(255) | lzo | f | 0 | f
```
Untuk informasi selengkapnya, lihat [PG\$1TABLE\$1DEF](https://docs.aws.amazon.com/redshift/latest/dg/r_PG_TABLE_DEF.html).
Anda juga dapat menggunakan editor kueri Amazon Redshift v2 untuk melihat semua tabel dalam skema tertentu dengan terlebih dahulu memilih database yang ingin Anda sambungkan.
## Lihat pengguna
Anda dapat menanyakan katalog PG\$1USER untuk melihat daftar semua pengguna, bersama dengan ID pengguna (USESYSID) dan hak istimewa pengguna.
```
SELECT * FROM pg_user;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
------------+----------+-------------+----------+-----------+----------+----------+-----------
rdsdb | 1 | true | true | true | ******** | infinity |
awsuser | 100 | true | true | false | ******** | |
guest | 104 | true | false | false | ******** | |
```
Nama pengguna digunakan `rdsdb` secara internal oleh Amazon Redshift untuk melakukan tugas administrasi dan pemeliharaan rutin. Anda dapat memfilter kueri untuk hanya menampilkan nama pengguna yang ditentukan pengguna dengan menambahkan `where usesysid > 1` ke pernyataan SELECT Anda.
```
SELECT * FROM pg_user WHERE usesysid > 1;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
------------+----------+-------------+----------+-----------+----------+----------+-----------
awsuser | 100 | true | true | false | ******** | |
guest | 104 | true | false | false | ******** | |
```
## Lihat pertanyaan terbaru
Pada contoh sebelumnya, ID pengguna (user\$1id) untuk `adminuser` adalah 100. Untuk mencantumkan empat kueri terbaru yang dijalankan oleh`adminuser`, Anda dapat menanyakan tampilan SYS\$1QUERY\$1HISTORY.
Anda dapat menggunakan tampilan ini untuk menemukan ID kueri (query\$1id) atau ID proses (session\$1id) untuk kueri yang baru saja dijalankan. Anda juga dapat menggunakan tampilan ini untuk memeriksa berapa lama waktu yang dibutuhkan kueri untuk diselesaikan. SYS\$1QUERY\$1HISTORY menyertakan 4.000 karakter pertama dari string kueri (query\$1text) untuk membantu Anda menemukan kueri tertentu. Gunakan klausa LIMIT dengan pernyataan SELECT Anda untuk membatasi hasil.
```
SELECT query_id, session_id, elapsed_time, query_text
FROM sys_query_history
WHERE user_id = 100
ORDER BY start_time desc
LIMIT 4;
```
Hasilnya terlihat seperti berikut ini.
```
query_id | session_id | elapsed_time | query_text
----------+--------------+---------------+----------------------------------------------------------------
892 | 21046 | 55868 | SELECT query, pid, elapsed, substring from ...
620 | 17635 | 1296265 | SELECT query, pid, elapsed, substring from ...
610 | 17607 | 82555 | SELECT * from DEMO;
596 | 16762 | 226372 | INSERT INTO DEMO VALUES (100);
```
## Tentukan ID sesi dari kueri yang sedang berjalan
Untuk mengambil informasi tabel sistem tentang kueri, Anda mungkin perlu menentukan ID sesi (ID proses) yang terkait dengan kueri tersebut. Atau, Anda mungkin perlu menemukan ID sesi untuk kueri yang masih berjalan. Misalnya, Anda memerlukan ID sesi jika Anda perlu membatalkan kueri yang terlalu lama untuk dijalankan di klaster yang disediakan. Anda dapat menanyakan tabel sistem STV\$1RECENTS untuk mendapatkan daftar sesi IDs untuk menjalankan kueri, bersama dengan string kueri yang sesuai. Jika kueri Anda mengembalikan beberapa sesi, Anda dapat melihat teks kueri untuk menentukan ID sesi mana yang Anda butuhkan.
Untuk menentukan ID sesi dari kueri yang sedang berjalan, jalankan pernyataan SELECT berikut.
```
SELECT session_id, user_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
# Batalkan kueri
Jika Anda menjalankan kueri yang memakan waktu terlalu lama atau menghabiskan sumber daya yang berlebihan, batalkan kueri. Misalnya, buat daftar penjual tiket yang mencakup nama penjual dan jumlah tiket yang terjual. Query berikut memilih data dari `SALES` tabel dan tabel dan `USERS` menggabungkan dua tabel dengan mencocokkan SELLERID dan USERID dalam klausa WHERE.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
WHERE sales.sellerid = users.userid
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
Hasilnya terlihat seperti berikut ini.
```
sellerid | firstname | lastname | sum
----------+-----------+----------+------
48950 | Nayda | Hood | 184
19123 | Scott | Simmons | 164
20029 | Drew | Mcguire | 164
36791 | Emerson | Delacruz | 160
13567 | Imani | Adams | 156
9697 | Dorian | Ray | 156
41579 | Harrison | Durham | 156
15591 | Phyllis | Clay | 152
3008 | Lucas | Stanley | 148
44956 | Rachel |Villarreal| 148
```
**catatan**
Ini adalah kueri yang kompleks. Untuk tutorial ini, Anda tidak perlu khawatir tentang bagaimana query ini dibangun.
Query sebelumnya berjalan dalam hitungan detik dan mengembalikan 2.102 baris.
Misalkan Anda lupa memasukkan klausa WHERE.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
Set hasil mencakup semua baris dalam tabel dikalikan dengan semua baris dalam `SALES` tabel (`USERS`49989\$13766). Ini disebut bergabung Cartesian, dan itu tidak direkomendasikan. Hasilnya lebih dari 188 juta baris dan membutuhkan waktu lama untuk dijalankan.
Untuk membatalkan kueri yang sedang berjalan, gunakan perintah CANCEL dengan ID sesi kueri. Dengan editor kueri Amazon Redshift v2 Anda dapat membatalkan kueri dengan memilih tombol batal saat kueri sedang berjalan.
Untuk menemukan ID sesi, mulai sesi baru dan kueri tabel STV\$1RECENTS, seperti yang ditunjukkan pada langkah sebelumnya. Contoh berikut menunjukkan bagaimana Anda dapat membuat hasil lebih mudah dibaca. Untuk melakukan ini, gunakan fungsi TRIM untuk memangkas spasi tambahan dan hanya menampilkan 20 karakter pertama dari string kueri.
Untuk menentukan ID sesi dari kueri yang sedang berjalan, jalankan pernyataan SELECT berikut.
```
SELECT user_id, session_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
Hasilnya terlihat seperti berikut ini.
```
user_id | session_id | start_time | query_text
---------+---------------+----------------------------+----------------------------------------------------------------
100 | 1073791534 | 2024-03-19 22:26:21.205739 | SELECT user_id, session_id, start_time, query_text FROM ...
```
Untuk membatalkan kueri dengan ID sesi`1073791534`, jalankan perintah berikut.
```
CANCEL 1073791534;
```
**catatan**
Perintah CANCEL tidak menghentikan transaksi. Untuk menghentikan atau memutar kembali transaksi, gunakan perintah ABORT atau ROLLBACK. Untuk membatalkan kueri yang terkait dengan transaksi, pertama-tama batalkan kueri lalu hentikan transaksi.
Jika kueri yang Anda batalkan dikaitkan dengan transaksi, gunakan perintah ABORT atau ROLLBACK untuk membatalkan transaksi dan membuang setiap perubahan yang dilakukan pada data:
```
ABORT;
```
Kecuali Anda masuk sebagai pengguna super, Anda hanya dapat membatalkan pertanyaan Anda sendiri. Superuser dapat membatalkan semua kueri.
Jika alat kueri Anda tidak mendukung kueri yang berjalan secara bersamaan, mulailah sesi lain untuk membatalkan kueri.
Untuk informasi selengkapnya tentang membatalkan kueri, lihat [CANCEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CANCEL.html) di Panduan Pengembang *Database Amazon Redshift*.
## Batalkan kueri menggunakan antrean superuser
Jika sesi Anda saat ini memiliki terlalu banyak kueri yang berjalan secara bersamaan, Anda mungkin tidak dapat menjalankan perintah CANCEL sampai kueri lain selesai. Dalam hal ini, jalankan perintah CANCEL menggunakan antrean kueri manajemen beban kerja yang berbeda.
Dengan menggunakan manajemen beban kerja, Anda dapat menjalankan kueri dalam antrian kueri yang berbeda sehingga Anda tidak perlu menunggu kueri lain selesai. Manajer beban kerja membuat antrian terpisah, yang disebut antrian Superuser, yang dapat Anda gunakan untuk pemecahan masalah. Untuk menggunakan antrian Superuser, masuk ke superuser dan atur grup kueri ke 'superuser' menggunakan perintah SET. Setelah menjalankan perintah Anda, setel ulang grup kueri menggunakan perintah RESET.
Untuk membatalkan kueri menggunakan antrean superuser, jalankan perintah ini.
```
SET query_group TO 'superuser';
CANCEL 1073791534;
RESET query_group;
```