Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Perintah SELECT
<a name="s3-select-sql-reference-select"></a>

**penting**  
Amazon S3 Select tidak lagi tersedia untuk pelanggan baru. Pelanggan Amazon S3 Select yang sudah ada dapat terus menggunakan fitur seperti biasa. [Pelajari selengkapnya](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select hanya mendukung perintah SQL `SELECT`. Klausul standar ANSI berikut didukung untuk `SELECT`: 


+ Daftar `SELECT`
+ Klausul `FROM` 
+ Klausul `WHERE`
+ Klausul `LIMIT`

**catatan**  
Kueri Amazon S3 Select saat ini tidak mendukung subkueri atau penggabungan.

## Daftar SELECT
<a name="s3-select-sql-reference-select-list"></a>

Daftar `SELECT` mencantumkan kolom, fungsi, dan ekspresi yang ingin Anda tampilkan dari kueri. Daftar ini mewakili output kueri. 

```
SELECT *
SELECT projection1 AS column_alias_1, projection2 AS column_alias_2
```

Bentuk pertama `SELECT` dengan `*` (tanda bintang) mengembalikan setiap baris yang melewati klausul `WHERE`, apa adanya. Bentuk kedua `SELECT` membuat baris dengan ekspresi skalar output **`projection1`** dan **`projection2`** yang ditentukan pengguna untuk setiap kolom.

## Klausul FROM
<a name="s3-select-sql-reference-from"></a>

Amazon S3 Select mendukung bentuk klausul `FROM` berikut:

```
FROM table_name
FROM table_name alias
FROM table_name AS alias
```

Dalam setiap bentuk klausul `FROM`, `table_name` adalah `S3Object` yang sedang dikuerikan. Pengguna yang berasal dari basis data relasional tradisional dapat menganggap hal ini sebagai skema basis data yang berisi beberapa tampilan di atas tabel.

Mengikuti SQL standar, klausul `FROM` membuat baris yang difilter dalam klausul `WHERE` dan diproyeksikan dalam daftar `SELECT`. 

Untuk objek JSON yang disimpan di Amazon S3 Select, Anda juga dapat menggunakan bentuk klausul `FROM` berikut:

```
FROM S3Object[*].path
FROM S3Object[*].path alias
FROM S3Object[*].path AS alias
```

Menggunakan bentuk klausul `FROM`, Anda dapat memilih dari array atau objek di dalam objek JSON. Anda dapat menentukan `path` menggunakan salah satu bentuk berikut:
+ Berdasarkan nama (dalam objek): `.name` atau `['name']`
+ Berdasarkan indeks (dalam array): `[index]`
+ Berdasarkan karakter wildcard (dalam objek): `.*`
+ Berdasarkan karakter wildcard (dalam array): `[*]`

**catatan**  
Bentuk klausul `FROM` ini hanya berfungsi dengan objek JSON.
Karakter wildcard selalu mengeluarkan setidaknya satu catatan. Apabila tidak ada catatan yang cocok, Amazon S3 Select mengeluarkan nilai `MISSING`. Selama serialisasi output (setelah kueri selesai berjalan), Amazon S3 Select menggantikan nilai `MISSING` dengan catatan kosong.
Fungsi agregat (`AVG`, `COUNT`, `MAX`, `MIN`, dan `SUM`) melewati nilai `MISSING`.
Apabila Anda tidak menyediakan alias saat menggunakan karakter wildcard, Anda dapat merujuk baris menggunakan elemen terakhir di jalur tersebut. Misalnya, Anda dapat memilih semua harga dari daftar pembukuan menggunakan kueri `SELECT price FROM S3Object[*].books[*].price`. Apabila jalur diakhiri karakter wildcard alih-alih nama, maka Anda dapat menggunakan nilai `_1` tersebut untuk merujuk ke baris. Misalnya, alih-alih `SELECT price FROM S3Object[*].books[*].price`, Anda dapat menggunakan kueri `SELECT _1.price FROM S3Object[*].books[*]`.
Amazon S3 Select selalu memperlakukan dokumen JSON sebagai array nilai tingkat root. Dengan demikian, sekalipun objek JSON yang Anda kueri hanya memiliki satu elemen root, klausul `FROM` harus dimulai dengan `S3Object[*]`. Namun, karena alasan kompatibilitas, Amazon S3 Select memungkinkan Anda menghilangkan karakter wildcard jika Anda tidak menyertakan jalur. Dengan demikian, klausul lengkap `FROM S3Object` setara dengan `FROM S3Object[*] as S3Object`. Apabila Anda menyertakan jalur, Anda juga harus menggunakan karakter wildcard. Jadi, `FROM S3Object` dan `FROM S3Object[*].path` keduanya adalah klausul yang valid, tetapi tidak dengan `FROM S3Object.path`.

**Example**  
**Contoh:**  
*Contoh 1*  
Contoh ini menampilkan hasil menggunakan set data dan kueri berikut:  

```
{ "Rules": [ {"id": "1"}, {"expr": "y > x"}, {"id": "2", "expr": "z = DEBUG"} ]}
{ "created": "June 27", "modified": "July 6" }
```

```
SELECT id FROM S3Object[*].Rules[*].id
```

```
{"id":"1"}
{}
{"id":"2"}
{}
```
Amazon S3 Select menghasilkan setiap hasil karena alasan berikut:  
+ `{"id":"id-1"}`–`S3Object[0].Rules[0].id` menghasilkan kecocokan.
+ `{}`–`S3Object[0].Rules[1].id` tidak cocok dengan catatan, jadi Amazon S3 Select mengeluarkan `MISSING`, yang kemudian diubah menjadi catatan kosong selama serialisasi output dan dikembalikan.
+ `{"id":"id-2"}`–`S3Object[0].Rules[2].id` menghasilkan kecocokan.
+ `{}`–`S3Object[1]` tidak cocok dengan `Rules`, jadi Amazon S3 Select mengeluarkan `MISSING`, yang kemudian diubah menjadi catatan kosong selama serialisasi output dan dikembalikan.
Apabila Anda tidak ingin Amazon S3 Select mengembalikan catatan kosong saat tidak menemukan kecocokan, Anda dapat menguji nilai `MISSING`. Kueri berikut mengembalikan hasil yang sama seperti kueri sebelumnya, tetapi nilai yang kosong dihilangkan:  

```
SELECT id FROM S3Object[*].Rules[*].id WHERE id IS NOT MISSING
```

```
{"id":"1"}
{"id":"2"}
```
*Contoh 2*  
Contoh ini menampilkan hasil menggunakan set data dan kueri berikut:  

```
{ "created": "936864000", "dir_name": "important_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": ".aws" }, { "name": "downloads" } ], "owner": "Amazon S3" }
{ "created": "936864000", "dir_name": "other_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": "my stuff" }, { "name": "backup" } ], "owner": "User" }
```

```
SELECT d.dir_name, d.files FROM S3Object[*] d
```

```
{"dir_name":"important_docs","files":[{"name":"."},{"name":".."},{"name":".aws"},{"name":"downloads"}]}
{"dir_name":"other_docs","files":[{"name":"."},{"name":".."},{"name":"my stuff"},{"name":"backup"}]}
```

```
SELECT _1.dir_name, _1.owner FROM S3Object[*]
```

```
{"dir_name":"important_docs","owner":"Amazon S3"}
{"dir_name":"other_docs","owner":"User"}
```

## Klausul WHERE
<a name="s3-select-sql-reference-where"></a>

Klausul `WHERE` mengikuti sintaks ini: 

```
WHERE condition
```

Klausul `WHERE` memfilter baris berdasarkan `condition`. Ketentuan adalah ekspresi yang memiliki hasil Boolean. Hanya baris yang syaratnya dievaluasi sebagai `TRUE` yang dikembalikan di hasilnya.

## Klausul LIMIT
<a name="s3-select-sql-reference-limit"></a>

Klausul `LIMIT` mengikuti sintaks ini: 

```
LIMIT number
```

Klausul `LIMIT` membatasi jumlah catatan yang Anda ingin kuerinya dikembalikan berdasarkan `number`.

## Akses atribut
<a name="s3-select-sql-reference-attribute-access"></a>

Klausul `SELECT` dan `WHERE` dapat merujuk ke data catatan menggunakan salah satu metode dalam bagian berikut, tergantung pada jika file yang dicari dalam format CSV atau JSON.

### CSV
<a name="s3-select-sql-reference-attribute-access-csv"></a>
+ **Nomor Kolom**–Anda dapat merujuk ke kolom *Nth* pada baris dengan nama kolom `_N`, dengan *`N`* adalah posisi kolom. Hitungan posisi dimulai pada 1. Misalnya, kolom pertama diberi nama `_1` dan kolom kedua diberi nama `_2`.

  Anda dapat merujuk ke kolom sebagai `_N` atau `alias._N`. Misalnya, `_2` dan `myAlias._2` adalah cara yang valid untuk merujuk ke kolom dalam daftar `SELECT` dan klausul `WHERE`.
+ **Header Kolom**–Untuk objek dalam format CSV yang memiliki baris header, header tersedia untuk daftar `SELECT` dan klausul `WHERE`. Secara khusus, seperti dalam SQL tradisional, dalam ekspresi klausul `SELECT` dan `WHERE`, Anda dapat melihat kolom dengan `alias.column_name` atau `column_name`.

### JSON
<a name="s3-select-sql-reference-attribute-access-json"></a>
+ **Dokumen**–Anda dapat mengakses bidang dokumen JSON sebagai `alias.name`. Anda juga dapat mengakses bidang bersarang, misalnya, `alias.name1.name2.name3`.
+ **Daftar**–Anda dapat mengakses elemen dalam daftar JSON menggunakan indeks berbasis nol dengan operator `[]`. Misalnya, Anda dapat mengakses elemen kedua dari daftar sebagai `alias[1]`. Anda dapat menggabungkan elemen daftar yang diakses dengan bidang, misalnya, `alias.name1.name2[1].name3`.
+ **Contoh:** Pertimbangkan objek JSON ini sebagai sampel set data:

  ```
  {"name": "Susan Smith",
  "org": "engineering",
  "projects":
      [
       {"project_name":"project1", "completed":false},
       {"project_name":"project2", "completed":true}
      ]
  }
  ```

  *Contoh 1*

  Kueri berikut mengembalikan hasil ini:

  ```
  Select s.name from S3Object s
  ```

  ```
  {"name":"Susan Smith"}
  ```

  *Contoh 2*

  Kueri berikut mengembalikan hasil ini:

  ```
  Select s.projects[0].project_name from S3Object s
  ```

  ```
  {"project_name":"project1"}
  ```

## Sensitivitas huruf besar/kecil pada nama header dan atribut
<a name="s3-select-sql-reference-case-sensitivity"></a>

Dengan Amazon S3 Select, Anda dapat menggunakan tanda petik dua untuk menunjukkan header kolom (untuk objek CSV) dan atribut (untuk objek JSON) yang peka terhadap huruf besar/kecil. Tanpa tanda petik dua, header dan atribut objek tidak sensitif terhadap huruf besar/kecil. Kesalahan akan muncul dalam kasus ambiguitas.

Contoh berikut adalah 1) objek Amazon S3 dalam format CSV dengan header bidang yang ditentukan, dan dengan `FileHeaderInfo` diatur ke `"Use"` untuk permintaan kueri; atau 2) objek Amazon S3 dalam format JSON dengan atribut yang ditentukan.

*Contoh 1:* Objek yang dikuerikan memiliki header atau atribut `NAME`.
+ Ekspresi berikut berhasil mengembalikan nilai dari objek. Karena tidak ada tanda petik, kueri tidak peka huruf besar/kecil.

  ```
  SELECT s.name from S3Object s
  ```
+ Ekspresi berikut menghasilkan kesalahan 400 `MissingHeaderName`. Karena terdapat tanda petik, kueri peka huruf besar/kecil. 

  ```
  SELECT s."name" from S3Object s
  ```

*Contoh 2:* Objek Amazon S3 yang dikuerikan memiliki satu header atau atribut dengan `NAME` header atau atribut lainnya dengan `name`.
+ Ekspresi berikut menghasilkan kesalahan 400 `AmbiguousFieldName`. Karena tidak ada tanda petik, kueri tidak sensitif terhadap huruf besar/kecil, tetapi terdapat dua kecocokan, jadi kesalahan dilemparkan.

  ```
  SELECT s.name from S3Object s
  ```
+ Ekspresi berikut berhasil mengembalikan nilai dari objek. Karena terdapat tanda petik, kueri peka huruf besar/kecil, sehingga tidak ada ambiguitas.

  ```
  SELECT s."NAME" from S3Object s
  ```

## Menggunakan kata kunci terpesan sebagai istilah yang ditetapkan pengguna
<a name="s3-select-sql-reference-using-keywords"></a>

Amazon S3 Select memiliki serangkaian kata kunci terpesan yang diperlukan untuk menjalankan ekspresi SQL yang digunakan untuk mengkueri konten objek. Kata kunci terpesan meliputi nama fungsi, jenis data, operator, dan sebagainya. Dalam beberapa kasus, istilah yang ditentukan pengguna, seperti header kolom (untuk file CSV) atau atribut (untuk objek JSON), dapat bertentangan dengan kata kunci terpesan. Pada saat hal ini terjadi, Anda harus menggunakan tanda petik dua untuk menunjukkan bahwa Anda sengaja menggunakan istilah khusus pengguna yang bertentangan dengan kata kunci terpesan. Apabila tidak, kesalahan penguraian 400 akan terjadi.

Untuk mengetahui daftar lengkap kata kunci terpesan, lihat [Kata kunci terpesan](s3-select-sql-reference-keyword-list.md).

Contoh berikut adalah 1) objek Amazon S3 dalam format CSV dengan header bidang yang ditentukan, dengan `FileHeaderInfo` diatur ke `"Use"` untuk permintaan kueri, atau 2) objek Amazon S3 dalam format JSON dengan atribut yang ditentukan.

*Contoh:* Objek yang dikuerikan memiliki header atau atribut bernama `CAST`, yang merupakan kata kunci terpesan.
+ Ekspresi berikut berhasil mengembalikan nilai dari objek. Karena tanda petik digunakan dalam kueri, S3 Select menggunakan header atau atribut yang ditentukan pengguna.

  ```
  SELECT s."CAST" from S3Object s
  ```
+ Ekspresi berikut menghasilkan kesalahan penguraian 400. Karena tidak ada tanda petik yang digunakan dalam kueri, `CAST` bertentangan dengan kata kunci terpesan.

  ```
  SELECT s.CAST from S3Object s
  ```

## Ekspresi skalar
<a name="s3-select-sql-reference-scalar"></a>

Dalam klausul `WHERE` dan daftar `SELECT`, Anda dapat memiliki *ekspresi skalar* SQL, yaitu ekspresi yang mengembalikan nilai skalar. Bentuknya adalah sebagai berikut:
+ ***`literal`*** 

  SQL literal. 
+ ***`column_reference`*** 

  Referensi ke kolom berupa `column_name` atau `alias.column_name`. 
+ **`unary_op`** **`expression`** 

  Dalam hal ini, ****`unary_op`**** adalah operator numerik SQL.
+ **`expression`** **`binary_op`** ***`expression`*** 

   Dalam hal ini, ****`binary_op`**** adalah operator biner SQL. 
+ **`func_name`** 

   Dalam hal ini, **`func_name`** adalah nama fungsi skalar yang diminta. 
+ ***`expression`*** `[ NOT ] BETWEEN` ****`expression`**** `AND` ****`expression`****
+ ***`expression`*** `LIKE` ****`expression`**** [ `ESCAPE` ***`expression`*** ]