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

# Referensi SQL untuk Amazon S3 Select
<a name="s3-select-sql-reference"></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/) 

Referensi ini berisi deskripsi elemen bahasa kueri terstruktur (SQL) yang didukung oleh Amazon S3 Select.

**Topics**
+ [Perintah SELECT](s3-select-sql-reference-select.md)
+ [Jenis data](s3-select-sql-reference-data-types.md)
+ [Operator](s3-select-sql-reference-operators.md)
+ [Kata kunci terpesan](s3-select-sql-reference-keyword-list.md)
+ [Fungsi SQL](s3-select-sql-reference-sql-functions.md)

# 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`*** ]

# Jenis data
<a name="s3-select-sql-reference-data-types"></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 mendukung beberapa jenis data primitif.

## Konversi jenis data
<a name="s3-select-sql-reference-data-conversion"></a>

Aturan umumnya adalah mengikuti fungsi `CAST` jika ditentukan. Apabila `CAST` tidak ditentukan, semua data input diperlakukan sebagai string. Dalam hal ini, Anda harus memasukkan data input Anda ke dalam jenis data yang relevan jika perlu.

Untuk informasi selengkapnya tentang fungsi `CAST`, lihat [CAST](s3-select-sql-reference-conversion.md#s3-select-sql-reference-cast).

## Jenis data yang didukung
<a name="s3-select-sql-reference-supported-data-types"></a>

Amazon S3 Select mendukung rangkaian jenis data primitif berikut.


|  Nama  |  Deskripsi  |  Contoh  | 
| --- | --- | --- | 
| `bool` | Nilai Boolean, baik `TRUE` ataupun `FALSE`. | `FALSE` | 
| `int`, `integer` | Bilangan bulat bertanda 8-byte dalam rentang -9.223.372.036.854.775.808 hingga 9.223.372.036.854.775.807.  | `100000` | 
| `string` | String panjang UTF8 variabel yang dikodekan. Batas default adalah 1 karakter. Batas karakter maksimum adalah 2.147.483.647.  | `'xyz'` | 
| `float` | Angka floating point 8-byte.  | `CAST(0.456 AS FLOAT)` | 
| `decimal`, `numeric` |  Angka dasar-10, dengan presisi maksimum 38 (yaitu, jumlah maksimal digit signifikan), dan dengan skala dalam rentang -231 hingga 231-1 (yaitu, eksponen dasar-10).  Amazon S3 Select mengabaikan skala dan presisi saat Anda memberikan keduanya secara bersamaan.   | `123.456 ` | 
| `timestamp` |  Timestamp mewakili momen waktu tertentu, selalu menyertakan offset lokal, dan mampu memiliki presisi arbitrer. Dalam format teks, timestamp mengikuti [catatan W3C tentang format tanggal dan waktu](https://www.w3.org/TR/NOTE-datetime), tetapi harus mengakhirinya dengan timestamp `T` setidaknya presisi sehari penuh. Beberapa detik fraksional diperbolehkan, dengan setidaknya satu digit presisi, dan maksimum tidak terbatas. Offset waktu lokal dapat dinyatakan sebagai offset jam:menit dari UTC, atau sebagai `Z` literal untuk menunjukkan waktu lokal UTC. Offset waktu lokal diperlukan pada timestamp dengan waktu dan tidak diizinkan pada nilai tanggal.  | `CAST('2007-04-05T14:30Z' AS TIMESTAMP)` | 

### Jenis Parquet yang didukung
<a name="s3-select-sql-reference-supported-data-types-parquet"></a>

Amazon S3 Select mendukung jenis Parquet berikut.
+ `DATE`
+ `DECIMAL`
+ `ENUM`
+ `INT(8)`
+ `INT(16)`
+ `INT(32)`
+ `INT(64)`
+ `LIST`
**catatan**  
Untuk output jenis `LIST` Parquet, Amazon S3 Select hanya mendukung format JSON. Namun, jika kueri membatasi data ke nilai sederhana, jenis `LIST` Parquet juga dapat dikuerikan dalam format CSV.
+ `STRING`
+ Presisi `TIMESTAMP` yang didukung (`MILLIS`/`MICROS`/`NANOS`)
**catatan**  
Timestamp yang disimpan sebagai `INT(96)` tidak didukung.   
Karena rentang jenis `INT(64)`, timestamp yang menggunakan unit `NANOS` hanya dapat mewakili nilai antara `1677-09-21 00:12:43` dan `2262-04-11 23:47:16`. Nilai di luar rentang ini tidak dapat diwakili dengan unit `NANOS`.

### Pemetaan jenis Parquet ke jenis data yang didukung di Amazon S3 Select
<a name="s3-select-sql-reference-supported-data-types-parquet-mapping"></a>


| Jenis Parquet | Jenis data yang didukung | 
| --- | --- | 
| `DATE` |  `timestamp`  | 
|  `DECIMAL`  |  `decimal`, `numeric`  | 
|  `ENUM`  |  `string`  | 
|  `INT(8)`  |  `int`, `integer`  | 
|  `INT(16)`  | `int`, `integer` | 
| `INT(32)` | `int`, `integer` | 
|  `INT(64)`  |  `decimal`, `numeric`  | 
|  `LIST`  |  Setiap jenis Parquet dalam daftar dipetakan ke jenis data yang sesuai.  | 
|  `STRING`  |  `string`  | 
|  `TIMESTAMP`  |  `timestamp`  | 

# Operator
<a name="s3-select-sql-reference-operators"></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 mendukung operator berikut.

## Operator logis
<a name="s3-select-sql-reference-loical-ops"></a>
+ `AND`
+ `NOT`
+ `OR`

## Operator perbandingan
<a name="s3-select-sql-reference-compare-ops"></a>
+ `<` 
+ `>` 
+ `<=`
+ `>=`
+ `=`
+ `<>`
+ `!=`
+ `BETWEEN`
+ `IN`–Sebagai contoh: `IN ('a', 'b', 'c')`

  

## Operator pencocokan pola
<a name="s3-select-sql-reference-pattern"></a>
+ `LIKE`
+ `_` (Cocok untuk setiap karakter)
+ `%` (Cocok untuk urutan karakter apa pun)

## Operator numerik
<a name="s3-select-sql-reference-unitary-ops"></a>
+ `IS NULL`
+ `IS NOT NULL`

## Operator matematika
<a name="s3-select-sql-referencemath-ops"></a>

Penambahan, pengurangan, perkalian, pembagian, dan modulo didukung, sebagai berikut:
+ \$1
+ -
+ \$1
+ /
+ %

## Prasyarat operator
<a name="s3-select-sql-reference-op-Precedence"></a>

Tabel berikut menunjukkan prasyarat operator dalam urutan menurun.


|  Operator atau elemen  |  Asosiatif |  Diperlukan  | 
| --- | --- | --- | 
| `-`  | kanan  | numerik minus  | 
| `*`, `/`, `%`  | kiri  | perkalian, pembagian, modulo  | 
| `+`, `-`  | kiri  | penambahan, pengurangan  | 
| `IN` |  | atur keanggotaan  | 
| `BETWEEN` |  | pengurungan rentang  | 
| `LIKE` |  | pencocokan pola string  | 
| `<``>` |  | kurang dari, lebih dari  | 
| `=` | kanan  | kesetaraan, penugasan | 
| `NOT` | kanan | negasi logis  | 
| `AND` | kiri | konjungsi logis  | 
| `OR` | kiri | disjungsi logis  | 

# Kata kunci terpesan
<a name="s3-select-sql-reference-keyword-list"></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/) 

Berikut adalah daftar kata kunci terpesan untuk Amazon S3 Select. Kata kunci ini mencakup nama fungsi, jenis data, operator, dan sebagainya, yang diperlukan untuk menjalankan ekspresi SQL yang digunakan untuk melakukan kueri konten objek.

```
absolute
action
add
all
allocate
alter
and
any
are
as
asc
assertion
at
authorization
avg
bag
begin
between
bit
bit_length
blob
bool
boolean
both
by
cascade
cascaded
case
cast
catalog
char
char_length
character
character_length
check
clob
close
coalesce
collate
collation
column
commit
connect
connection
constraint
constraints
continue
convert
corresponding
count
create
cross
current
current_date
current_time
current_timestamp
current_user
cursor
date
day
deallocate
dec
decimal
declare
default
deferrable
deferred
delete
desc
describe
descriptor
diagnostics
disconnect
distinct
domain
double
drop
else
end
end-exec
escape
except
exception
exec
execute
exists
external
extract
false
fetch
first
float
for
foreign
found
from
full
get
global
go
goto
grant
group
having
hour
identity
immediate
in
indicator
initially
inner
input
insensitive
insert
int
integer
intersect
interval
into
is
isolation
join
key
language
last
leading
left
level
like
limit
list
local
lower
match
max
min
minute
missing
module
month
names
national
natural
nchar
next
no
not
null
nullif
numeric
octet_length
of
on
only
open
option
or
order
outer
output
overlaps
pad
partial
pivot
position
precision
prepare
preserve
primary
prior
privileges
procedure
public
read
real
references
relative
restrict
revoke
right
rollback
rows
schema
scroll
second
section
select
session
session_user
set
sexp
size
smallint
some
space
sql
sqlcode
sqlerror
sqlstate
string
struct
substring
sum
symbol
system_user
table
temporary
then
time
timestamp
timezone_hour
timezone_minute
to
trailing
transaction
translate
translation
trim
true
tuple
union
unique
unknown
unpivot
update
upper
usage
user
using
value
values
varchar
varying
view
when
whenever
where
with
work
write
year
zone
```

# Fungsi SQL
<a name="s3-select-sql-reference-sql-functions"></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 mendukung fungsi SQL berikut.

**Topics**
+ [Fungsi agregat](s3-select-sql-reference-aggregate.md)
+ [Fungsi kondisional](s3-select-sql-reference-conditional.md)
+ [Fungsi konversi](s3-select-sql-reference-conversion.md)
+ [Fungsi tanggal](s3-select-sql-reference-date.md)
+ [Fungsi string](s3-select-sql-reference-string.md)

# Fungsi agregat
<a name="s3-select-sql-reference-aggregate"></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 mendukung fungsi agregat berikut.


| Fungsi | Jenis Argumen | Jenis pengembalian | 
| --- | --- | --- | 
| `AVG(expression)` | `INT`, `FLOAT`, `DECIMAL` | `DECIMAL` untuk argumen `INT`, `FLOAT` untuk argumen floating point; jika tidak, sama dengan jenis data argumen. | 
| `COUNT` |  `-`  | `INT` | 
| `MAX(expression)` | `INT`, `DECIMAL` | Sama seperti jenis argumen. | 
| `MIN(expression)` | `INT`, `DECIMAL` | Sama seperti jenis argumen. | 
| `SUM(expression)` | `INT`, `FLOAT`, `DOUBLE`, `DECIMAL` | `INT` untuk argumen `INT`, `FLOAT` untuk argumen floating point; jika tidak, sama dengan jenis data argumen. | 

## Contoh SUM
<a name="s3-select-sql-reference-aggregate-case-examples"></a>

Untuk menggabungkan ukuran objek total suatu folder dalam [laporan Inventaris S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-inventory.html), gunakan ekspresi `SUM`.

Laporan Inventaris S3 berikut adalah file CSV yang dikompresi dengan GZIP. Terdapat tiga kolom.
+ Kolom pertama adalah nama bucket S3 (*`DOC-EXAMPLE-BUCKET`*) yang digunakan untuk laporan Inventaris S3.
+ Kolom kedua adalah nama kunci objek yang secara unik mengidentifikasi objek dalam bucket.

  Nilai `example-folder/` di baris pertama adalah untuk folder `example-folder`. Di Amazon S3, saat Anda membuat folder di bucket, S3 membuat objek 0-byte dengan kunci yang diatur ke nama folder yang Anda berikan.

  Nilai `example-folder/object1` di baris kedua adalah untuk objek `object1` di folder `example-folder`.

  Nilai `example-folder/object2` di baris ketiga adalah untuk objek `object2` di folder `example-folder`.

  Untuk informasi selengkapnya tentang folder S3, lihat [Mengatur objek di konsol Amazon S3 dengan menggunakan folder](using-folders.md).
+ Kolom ketiga adalah ukuran objek dalam byte.

```
"DOC-EXAMPLE-BUCKET","example-folder/","0"
"DOC-EXAMPLE-BUCKET","example-folder/object1","2011267"
"DOC-EXAMPLE-BUCKET","example-folder/object2","1570024"
```

Untuk menggunakan ekspresi `SUM` guna menghitung ukuran total folder `example-folder`, jalankan kueri SQL dengan Amazon S3 Select.

```
SELECT SUM(CAST(_3 as INT)) FROM s3object s WHERE _2 LIKE 'example-folder/%' AND _2 != 'example-folder/';
```

Hasil Kueri: 

```
3581291
```

# Fungsi kondisional
<a name="s3-select-sql-reference-conditional"></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 mendukung fungsi kondisional berikut.

**Topics**
+ [CASE](#s3-select-sql-reference-case)
+ [COALESCE](#s3-select-sql-reference-coalesce)
+ [NULLIF](#s3-select-sql-reference-nullif)

## CASE
<a name="s3-select-sql-reference-case"></a>

Ekspresi `CASE` adalah ekspresi kondisional yang serupa dengan pernyataan `if/then/else` yang ditemukan dalam bahasa lain. `CASE`digunakan untuk menentukan hasil jika terdapat beberapa kondisi. Terdapat dua jenis ekspresi `CASE`: sederhana dan dicari.

Dalam ekspresi `CASE` sederhana, ekspresi dibandingkan dengan nilai. Ketika kecocokan ditemukan, tindakan yang ditentukan dalam klausul `THEN` diterapkan. Apabila kecocokan tidak ditemukan, tindakan dalam klausul `ELSE` diterapkan.

Dalam ekspresi `CASE` yang dicari, masing-masing `CASE` dievaluasi berdasarkan ekspresi Boolean, dan pernyataan `CASE` mengembalikan kecocokan pertama `CASE`. Jika tidak ada kecocokan `CASE` yang ditemukan di antara klausul `WHEN`, tindakan dalam klausul `ELSE` dikembalikan.

### Sintaks
<a name="s3-select-sql-reference-case-syntax"></a>

**catatan**  
Saat ini, Amazon S3 Select tidak mendukung `ORDER BY` atau kueri yang berisi baris baru. Pastikan Anda menggunakan kueri tanpa jeda baris.

Berikut ini adalah pernyataan `CASE` sederhana yang digunakan untuk mencocokkan kondisi:

```
CASE expression WHEN value THEN result [WHEN...] [ELSE result] END					
```

Berikut ini adalah pernyataan `CASE` yang dicari yang digunakan untuk mengevaluasi setiap kondisi:

```
CASE WHEN boolean condition THEN result [WHEN ...] [ELSE result] END					
```

### Contoh
<a name="s3-select-sql-reference-case-examples"></a>

**catatan**  
Apabila Anda menggunakan konsol Amazon S3 untuk menjalankan contoh berikut dan file CSV berisi baris header, pilih **Kecualikan baris pertama data CSV**. 

**Contoh 1:** Gunakan ekspresi `CASE` sederhana untuk mengganti `New York City` dengan `Big Apple` dalam kueri. Ganti semua nama kota lainnya dengan `other`.

```
SELECT venuecity, CASE venuecity WHEN 'New York City' THEN 'Big Apple' ELSE 'other' END FROM S3Object;
```

Hasil kueri: 

```
venuecity        |   case
-----------------+-----------
Los Angeles      | other
New York City    | Big Apple
San Francisco    | other
Baltimore        | other
...
```

**Contoh 2:** Gunakan ekspresi `CASE` yang dicari untuk menetapkan nomor grup berdasarkan nilai `pricepaid` penjualan tiket individu:

```
SELECT pricepaid, CASE WHEN CAST(pricepaid as FLOAT) < 10000 THEN 'group 1' WHEN CAST(pricepaid as FLOAT) > 10000 THEN 'group 2' ELSE 'group 3' END FROM S3Object;					
```

Hasil kueri: 

```
pricepaid |  case
-----------+---------
12624.00 | group 2
10000.00 | group 3
10000.00 | group 3
9996.00 | group 1
9988.00 | group 1
...
```

## COALESCE
<a name="s3-select-sql-reference-coalesce"></a>

`COALESCE` mengevaluasi argumen secara berurutan dan mengembalikan nilai non-tidak diketahui pertama, yaitu, nilai non-null atau non-hilang yang pertama. Fungsi ini tidak memperbanyak nilai null dan hilang.

### Sintaks
<a name="s3-select-sql-reference-coalesce-syntax"></a>

```
COALESCE ( expression, expression, ... )
```

### Parameter
<a name="s3-select-sql-reference-coalesce-parameters"></a>

 *`expression`*   
Ekspresi target tempat fungsi beroperasi.

### Contoh
<a name="s3-select-sql-reference-coalesce-examples"></a>

```
COALESCE(1)                -- 1
COALESCE(null)             -- null
COALESCE(null, null)       -- null
COALESCE(missing)          -- null
COALESCE(missing, missing) -- null
COALESCE(1, null)          -- 1
COALESCE(null, null, 1)    -- 1
COALESCE(null, 'string')   -- 'string'
COALESCE(missing, 1)       -- 1
```

## NULLIF
<a name="s3-select-sql-reference-nullif"></a>

Dengan dua ekspresi, `NULLIF` mengembalikan `NULL` jika kedua ekspresi tersebut mengevaluasi nilai yang sama; jika tidak, `NULLIF` mengembalikan hasil evaluasi ke ekspresi yang pertama.

### Sintaks
<a name="s3-select-sql-reference-nullif-syntax"></a>

```
NULLIF ( expression1, expression2 )
```

### Parameter
<a name="s3-select-sql-reference-nullif-parameters"></a>

 `expression1, expression2`   
Ekspresi target tempat fungsi beroperasi.

### Contoh
<a name="s3-select-sql-reference-nullif-examples"></a>

```
NULLIF(1, 1)             -- null
NULLIF(1, 2)             -- 1
NULLIF(1.0, 1)           -- null
NULLIF(1, '1')           -- 1
NULLIF([1], [1])         -- null
NULLIF(1, NULL)          -- 1
NULLIF(NULL, 1)          -- null
NULLIF(null, null)       -- null
NULLIF(missing, null)    -- null
NULLIF(missing, missing) -- null
```

# Fungsi konversi
<a name="s3-select-sql-reference-conversion"></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 mendukung fungsi konversi berikut.

**Topics**
+ [CAST](#s3-select-sql-reference-cast)

## CAST
<a name="s3-select-sql-reference-cast"></a>

Fungsi `CAST` mengonversi suatu entitas, seperti ekspresi yang mengevaluasi ke nilai tunggal, dari satu jenis ke lainnya. 

### Sintaks
<a name="s3-select-sql-reference-cast-syntax"></a>

```
CAST ( expression AS data_type )
```

### Parameter
<a name="s3-select-sql-reference-cast-parameters"></a>

 *`expression`*   
Kombinasi satu atau beberapa nilai, operator, dan fungsi SQL yang mengevaluasi nilai.

 *`data_type`*   
Jenis data target, seperti `INT`, untuk menghadirkan ekspresi. Untuk daftar jenis data yang didukung, lihat [Jenis data](s3-select-sql-reference-data-types.md).

### Contoh
<a name="s3-select-sql-reference-cast-examples"></a>

```
CAST('2007-04-05T14:30Z' AS TIMESTAMP)
CAST(0.456 AS FLOAT)
```

# Fungsi tanggal
<a name="s3-select-sql-reference-date"></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 mendukung fungsi tanggal berikut.

**Topics**
+ [DATE\$1ADD](#s3-select-sql-reference-date-add)
+ [DATE\$1DIFF](#s3-select-sql-reference-date-diff)
+ [EXTRACT](#s3-select-sql-reference-extract)
+ [TO\$1STRING](#s3-select-sql-reference-to-string)
+ [TO\$1TIMESTAMP](#s3-select-sql-reference-to-timestamp)
+ [UTCNOW](#s3-select-sql-reference-utcnow)

## DATE\$1ADD
<a name="s3-select-sql-reference-date-add"></a>

Dengan bagian tanggal, kuantitas, dan timestamp, `DATE_ADD` mengembalikan timestamp yang diperbarui dengan mengubah bagian tanggal berdasarkan kuantitas.

### Sintaks
<a name="s3-select-sql-reference-date-add-syntax"></a>

```
DATE_ADD( date_part, quantity, timestamp )
```

### Parameter
<a name="s3-select-sql-reference-date-add-parameters"></a>

*`date_part`*   
Menentukan bagian dari tanggal untuk diubah. Ini dapat berupa salah satu dari berikut ini:  
+ tahun
+ bulan
+ hari
+ jam
+ menit
+ detik

 *`quantity`*   
Nilai yang diterapkan pada timestamp yang diperbarui. Nilai positif untuk `quantity` ditambahkan ke date\$1part timestamp, dan pengurangan nilai negatif.

 *`timestamp`*   
Timestamp target tempat fungsi beroperasi.

### Contoh
<a name="s3-select-sql-reference-date-add-examples"></a>

```
DATE_ADD(year, 5, `2010-01-01T`)                -- 2015-01-01 (equivalent to 2015-01-01T)
DATE_ADD(month, 1, `2010T`)                     -- 2010-02T (result will add precision as necessary)
DATE_ADD(month, 13, `2010T`)                    -- 2011-02T
DATE_ADD(day, -1, `2017-01-10T`)                -- 2017-01-09 (equivalent to 2017-01-09T)
DATE_ADD(hour, 1, `2017T`)                      -- 2017-01-01T01:00-00:00
DATE_ADD(hour, 1, `2017-01-02T03:04Z`)          -- 2017-01-02T04:04Z
DATE_ADD(minute, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:05:05.006Z
DATE_ADD(second, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:04:06.006Z
```

## DATE\$1DIFF
<a name="s3-select-sql-reference-date-diff"></a>

Dengan bagian tanggal dan dua timestamp yang valid, `DATE_DIFF` mengembalikan selisih bagian tanggal. Nilai yang dikembalikan adalah bilangan bulat negatif ketika nilai `date_part` dari `timestamp1` lebih dari nilai `date_part` dari `timestamp2`. Nilai yang dikembalikan adalah bilangan bulat positif ketika nilai `date_part` dari `timestamp1` kurang dari nilai `date_part` dari `timestamp2`.

### Sintaks
<a name="s3-select-sql-reference-date-diff-syntax"></a>

```
DATE_DIFF( date_part, timestamp1, timestamp2 )
```

### Parameter
<a name="s3-select-sql-reference-date-diff-parameters"></a>

 **`date_part`**   
Menentukan bagian mana dari timestamp untuk dibandingkan. Untuk definisi `date_part`, lihat [DATE\$1ADD](#s3-select-sql-reference-date-add).

 **`timestamp1`**   
Timestamp pertama untuk dibandingkan.

 **`timestamp2`**   
Timestamp kedua untuk dibandingkan.

### Contoh
<a name="s3-select-sql-reference-date-diff-examples"></a>

```
DATE_DIFF(year, `2010-01-01T`, `2011-01-01T`)            -- 1
DATE_DIFF(year, `2010T`, `2010-05T`)                     -- 4 (2010T is equivalent to 2010-01-01T00:00:00.000Z)
DATE_DIFF(month, `2010T`, `2011T`)                       -- 12
DATE_DIFF(month, `2011T`, `2010T`)                       -- -12
DATE_DIFF(day, `2010-01-01T23:00`, `2010-01-02T01:00`) -- 0 (need to be at least 24h apart to be 1 day apart)
```

## EXTRACT
<a name="s3-select-sql-reference-extract"></a>

Dengan bagian tanggal dan timestamp, `EXTRACT` mengembalikan nilai bagian tanggal timestamp.

### Sintaks
<a name="s3-select-sql-reference-extract-syntax"></a>

```
EXTRACT( date_part FROM timestamp )
```

### Parameter
<a name="s3-select-sql-reference-extract-parameters"></a>

 **`date_part`**   
Menentukan bagian dari timestamp untuk diekstrak. Ini dapat berupa salah satu dari berikut ini:  
+ `YEAR`
+ `MONTH`
+ `DAY`
+ `HOUR`
+ `MINUTE`
+ `SECOND`
+ `TIMEZONE_HOUR`
+ `TIMEZONE_MINUTE`

 **`timestamp`**   
Timestamp target tempat fungsi beroperasi.

### Contoh
<a name="s3-select-sql-reference-extract-examples"></a>

```
EXTRACT(YEAR FROM `2010-01-01T`)                           -- 2010
EXTRACT(MONTH FROM `2010T`)                                -- 1 (equivalent to 2010-01-01T00:00:00.000Z)
EXTRACT(MONTH FROM `2010-10T`)                             -- 10
EXTRACT(HOUR FROM `2017-01-02T03:04:05+07:08`)             -- 3
EXTRACT(MINUTE FROM `2017-01-02T03:04:05+07:08`)           -- 4
EXTRACT(TIMEZONE_HOUR FROM `2017-01-02T03:04:05+07:08`)    -- 7
EXTRACT(TIMEZONE_MINUTE FROM `2017-01-02T03:04:05+07:08`)  -- 8
```

## TO\$1STRING
<a name="s3-select-sql-reference-to-string"></a>

Dengan timestamp dan pola format, `TO_STRING` mengembalikan representasi string timestamp dalam format yang diberikan.

### Sintaks
<a name="s3-select-sql-reference-size-syntax"></a>

```
TO_STRING ( timestamp time_format_pattern )
```

### Parameter
<a name="s3-select-sql-reference-size-parameters"></a>

 *`timestamp`*   
Timestamp target tempat fungsi beroperasi.

 *`time_format_pattern`*   
String yang memiliki interpretasi karakter khusus berikut:      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonS3/latest/userguide/s3-select-sql-reference-date.html)

### Contoh
<a name="s3-select-sql-reference-size-examples"></a>

```
TO_STRING(`1969-07-20T20:18Z`,  'MMMM d, y')                    -- "July 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMM d, yyyy')                   -- "Jul 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'M-d-yy')                        -- "7-20-69"
TO_STRING(`1969-07-20T20:18Z`, 'MM-d-y')                        -- "07-20-1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMMM d, y h:m a')               -- "July 20, 1969 8:18 PM"
TO_STRING(`1969-07-20T20:18Z`, 'y-MM-dd''T''H:m:ssX')           -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00Z`, 'y-MM-dd''T''H:m:ssX')     -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXX')   -- "1969-07-20T20:18:00+0800"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXXX')  -- "1969-07-20T20:18:00+08:00"
```

## TO\$1TIMESTAMP
<a name="s3-select-sql-reference-to-timestamp"></a>

Dengan string, `TO_TIMESTAMP` mengonversi menjadi timestamp. `TO_TIMESTAMP` adalah operasi terbalik `TO_STRING`.

### Sintaks
<a name="s3-select-sql-reference-to-timestamp-syntax"></a>

```
TO_TIMESTAMP ( string )
```

### Parameter
<a name="s3-select-sql-reference-to-timestamp-parameters"></a>

 *`string`*   
String target tempat fungsi beroperasi.

### Contoh
<a name="s3-select-sql-reference-to-timestamp-examples"></a>

```
TO_TIMESTAMP('2007T')                         -- `2007T`
TO_TIMESTAMP('2007-02-23T12:14:33.079-08:00') -- `2007-02-23T12:14:33.079-08:00`
```

## UTCNOW
<a name="s3-select-sql-reference-utcnow"></a>

`UTCNOW` mengembalikan waktu saat ini dalam UTC sebagai timestamp.

### Sintaks
<a name="s3-select-sql-reference-utcnow-syntax"></a>

```
UTCNOW()
```

### Parameter
<a name="s3-select-sql-reference-utcnow-parameters"></a>

`UTCNOW` tidak menggunakan parameter.

### Contoh
<a name="s3-select-sql-reference-utcnow-examples"></a>

```
UTCNOW() -- 2017-10-13T16:02:11.123Z
```

# Fungsi string
<a name="s3-select-sql-reference-string"></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 mendukung fungsi string berikut.

**Topics**
+ [CHAR\$1LENGTH, CHARACTER\$1LENGTH](#s3-select-sql-reference-char-length)
+ [LOWER](#s3-select-sql-reference-lower)
+ [SUBSTRING](#s3-select-sql-reference-substring)
+ [TRIM](#s3-select-sql-reference-trim)
+ [UPPER](#s3-select-sql-reference-upper)

## CHAR\$1LENGTH, CHARACTER\$1LENGTH
<a name="s3-select-sql-reference-char-length"></a>

`CHAR_LENGTH` (atau`CHARACTER_LENGTH`) menghitung jumlah karakter dalam string yang ditentukan.

**catatan**  
`CHAR_LENGTH` dan `CHARACTER_LENGTH` adalah sinonim.

### Sintaks
<a name="s3-select-sql-reference-char-length-syntax"></a>

```
CHAR_LENGTH ( string )
```

### Parameter
<a name="s3-select-sql-reference-char-length-parameters"></a>

 *`string`*   
String target tempat fungsi beroperasi.

### Contoh
<a name="s3-select-sql-reference-char-length-examples"></a>

```
CHAR_LENGTH('')          -- 0
CHAR_LENGTH('abcdefg')   -- 7
```

## LOWER
<a name="s3-select-sql-reference-lower"></a>

Dengan string, `LOWER` mengubah semua karakter huruf besar menjadi karakter huruf kecil. Setiap karakter yang tidak dalam huruf besar tidak berubah.

### Sintaks
<a name="s3-select-sql-reference-lower-syntax"></a>

```
LOWER ( string )
```

### Parameter
<a name="s3-select-sql-reference-lower-parameters"></a>

 **`string`**   
String target tempat fungsi beroperasi.

### Contoh
<a name="s3-select-sql-reference-lower-examples"></a>

```
LOWER('AbCdEfG!@#$') -- 'abcdefg!@#$'
```

## SUBSTRING
<a name="s3-select-sql-reference-substring"></a>

Dengan string, indeks awal, dan secara opsional panjang, `SUBSTRING`mengembalikan substring dari indeks awal hingga ujung string, atau hingga panjang yang disediakan.

**catatan**  
Karakter pertama dari string input memiliki posisi indeks 1.  
 Jika `start` < 1, tanpa panjang yang ditentukan, posisi indeks diatur ke 1. 
 Jika `start` < 1, dengan panjang yang ditentukan, posisi indeks diatur ke `start + length -1`. 
 Jika `start + length -1` < 0, string kosong dikembalikan. 
 Jika `start + length -1` > = 0, substring dimulai pada posisi indeks 1 dengan panjang `start + length - 1` dikembalikan. 

### Sintaks
<a name="s3-select-sql-reference-substring-syntax"></a>

```
SUBSTRING( string FROM start [ FOR length ] )
```

### Parameter
<a name="s3-select-sql-reference-substring-parameters"></a>

 **`string`**   
String target tempat fungsi beroperasi.

 **`start`**   
Posisi awal string.

 **`length`**   
Panjang substring untuk dikembalikan. Apabila tidak ada, lanjutkan ke akhir string.

### Contoh
<a name="s3-select-sql-reference-substring-examples"></a>

```
SUBSTRING("123456789", 0)      -- "123456789"
SUBSTRING("123456789", 1)      -- "123456789"
SUBSTRING("123456789", 2)      -- "23456789"
SUBSTRING("123456789", -4)     -- "123456789"
SUBSTRING("123456789", 0, 999) -- "123456789" 
SUBSTRING("123456789", 1, 5)   -- "12345"
```

## TRIM
<a name="s3-select-sql-reference-trim"></a>

Memangkas karakter di depan atau di belakang string. Karakter default yang harus dihapus adalah spasi (`' '`).

### Sintaks
<a name="s3-select-sql-reference-trim-syntax"></a>

```
TRIM ( [[LEADING | TRAILING | BOTH remove_chars] FROM] string )
```

### Parameter
<a name="s3-select-sql-reference-trim-parameters"></a>

 **`string`**   
String target tempat fungsi beroperasi.

 `LEADING` \$1 `TRAILING` \$1 `BOTH`   
Parameter ini menunjukkan jika akan memangkas karakter di depan atau di belakang, atau karakter di depan dan di belakang.

 **`remove_chars`**   
Set karakter untuk dihapus. `remove_chars` dapat berupa string dengan panjang > 1. Fungsi ini mengembalikan string dengan karakter apa pun dari `remove_chars` yang ditemukan di awal atau akhir string yang dihapus.

### Contoh
<a name="s3-select-sql-reference-trim-examples"></a>

```
TRIM('       foobar         ')               -- 'foobar'
TRIM('      \tfoobar\t         ')            -- '\tfoobar\t'
TRIM(LEADING FROM '       foobar         ')  -- 'foobar         '
TRIM(TRAILING FROM '       foobar         ') -- '       foobar'
TRIM(BOTH FROM '       foobar         ')     -- 'foobar'
TRIM(BOTH '12' FROM '1112211foobar22211122') -- 'foobar'
```

## UPPER
<a name="s3-select-sql-reference-upper"></a>

Dengan string, `UPPER` mengubah semua karakter huruf kecil menjadi karakter huruf besar. Setiap karakter yang tidak dalam huruf kecil tidak berubah.

### Sintaks
<a name="s3-select-sql-reference-upper-syntax"></a>

```
UPPER ( string )
```

### Parameter
<a name="s3-select-sql-reference-upper-parameters"></a>

 **`string`**   
String target tempat fungsi beroperasi.

### Contoh
<a name="s3-select-sql-reference-upper-examples"></a>

```
UPPER('AbCdEfG!@#$') -- 'ABCDEFG!@#$'
```