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.
# Fungsi tanggal dan waktu
Di bagian ini, Anda dapat menemukan informasi tentang fungsi skalar tanggal dan waktu yang didukung Amazon Redshift.
**Topics**
+ [Ringkasan fungsi tanggal dan waktu](#date-functions-summary)
+ [Fungsi tanggal dan waktu dalam transaksi](#date-functions-transactions)
+ [Fungsi khusus node pemimpin yang tidak digunakan lagi](#date-functions-deprecated)
+ [\$1 Operator (Penggabungan)](r_DATE-CONCATENATE_function.md)
+ [Fungsi ADD\$1MONTHS](r_ADD_MONTHS.md)
+ [Fungsi AT TIME ZONE](r_AT_TIME_ZONE.md)
+ [Fungsi CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md)
+ [Fungsi CURRENT\$1DATE](r_CURRENT_DATE_function.md)
+ [Fungsi DATE\$1CMP](r_DATE_CMP.md)
+ [Fungsi DATE\$1CMP\$1TIMESTAMP](r_DATE_CMP_TIMESTAMP.md)
+ [Fungsi DATE\$1CMP\$1TIMESTAMPTZ](r_DATE_CMP_TIMESTAMPTZ.md)
+ [Fungsi DATEADD](r_DATEADD_function.md)
+ [Fungsi DATEDIFF](r_DATEDIFF_function.md)
+ [Fungsi DATE\$1PART](r_DATE_PART_function.md)
+ [Fungsi DATE\$1PART\$1YEAR](r_DATE_PART_YEAR.md)
+ [Fungsi DATE\$1TRUNC](r_DATE_TRUNC.md)
+ [Fungsi EKSTRAK](r_EXTRACT_function.md)
+ [fungsi GETDATE](r_GETDATE.md)
+ [Fungsi INTERVAL\$1CMP](r_INTERVAL_CMP.md)
+ [Fungsi LAST\$1DAY](r_LAST_DAY.md)
+ [Fungsi MONTHS\$1BETWEEN](r_MONTHS_BETWEEN_function.md)
+ [fungsi NEXT\$1DAY](r_NEXT_DAY.md)
+ [fungsi SYSDATE](r_SYSDATE.md)
+ [Fungsi TIMEOFDAY](r_TIMEOFDAY_function.md)
+ [Fungsi TIMESTAMP\$1CMP](r_TIMESTAMP_CMP.md)
+ [Fungsi TIMESTAMP\$1CMP\$1DATE](r_TIMESTAMP_CMP_DATE.md)
+ [Fungsi TIMESTAMP\$1CMP\$1TIMESTAMPTZ](r_TIMESTAMP_CMP_TIMESTAMPTZ.md)
+ [Fungsi TIMESTAMPTZ\$1CMP](r_TIMESTAMPTZ_CMP.md)
+ [Fungsi TIMESTAMPTZ\$1CMP\$1DATE](r_TIMESTAMPTZ_CMP_DATE.md)
+ [Fungsi TIMESTAMPTZ\$1CMP\$1TIMESTAMP](r_TIMESTAMPTZ_CMP_TIMESTAMP.md)
+ [Fungsi TIMEZONE](r_TIMEZONE.md)
+ [Fungsi TO\$1TIMESTAMP](r_TO_TIMESTAMP.md)
+ [Fungsi TRUNC](r_TRUNC_date.md)
+ [Bagian tanggal untuk fungsi tanggal atau stempel waktu](r_Dateparts_for_datetime_functions.md)
## Ringkasan fungsi tanggal dan waktu
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/Date_functions_header.html)
**catatan**
Detik kabisat tidak dipertimbangkan dalam perhitungan waktu berlalu.
## Fungsi tanggal dan waktu dalam transaksi
Ketika Anda menjalankan fungsi berikut dalam blok transaksi (BEGIN... END), fungsi mengembalikan tanggal mulai atau waktu transaksi saat ini, bukan awal dari pernyataan saat ini.
+ SYSDATE
+ TIMESTAMP
+ CURRENT\$1DATE
Fungsi-fungsi berikut selalu mengembalikan tanggal mulai atau waktu pernyataan saat ini, bahkan ketika mereka berada dalam blok transaksi.
+ GETDATE
+ WAKTUHARI
## Fungsi khusus node pemimpin yang tidak digunakan lagi
Fungsi tanggal berikut tidak digunakan lagi karena hanya berjalan pada node pemimpin. Untuk informasi selengkapnya, lihat [Fungsi simpul pemimpin—hanya](c_SQL_functions_leader_node_only.md).
+ USIA. Gunakan [Fungsi DATEDIFF](r_DATEDIFF_function.md) sebagai gantinya.
+ CURRENT\$1TIME. Gunakan [fungsi GETDATE](r_GETDATE.md) atau [SYSDATE](r_SYSDATE.md) sebagai gantinya.
+ CURRENT\$1TIMESTAMP. Gunakan [fungsi GETDATE](r_GETDATE.md) atau [SYSDATE](r_SYSDATE.md) sebagai gantinya.
+ WAKTU LOKAL. Gunakan [fungsi GETDATE](r_GETDATE.md) atau [SYSDATE](r_SYSDATE.md) sebagai gantinya.
+ STEMPEL WAKTU LOKAL. Gunakan [fungsi GETDATE](r_GETDATE.md) atau [SYSDATE](r_SYSDATE.md) sebagai gantinya.
+ TIDAK TERBATAS
+ SEKARANG. Gunakan [fungsi GETDATE](r_GETDATE.md) atau [SYSDATE](r_SYSDATE.md) sebagai gantinya. Jika Anda menggunakan fungsi NOW dalam tampilan terwujud, ia akan menetapkan ke stempel waktu pembuatan tampilan terwujud, bukan stempel waktu saat ini.
# \$1 Operator (Penggabungan)
Menggabungkan TANGGAL ke TIME atau TIMETZ di kedua sisi simbol \$1 dan mengembalikan TIMESTAMP atau TIMESTAMPTZ.
## Sintaksis
```
date + {time | timetz}
```
Urutan argumen dapat dibalik. Misalnya, **waktu\$1tanggal**.
## Pendapat
*tanggal*
Kolom tipe data `DATE` atau ekspresi yang secara implisit mengevaluasi tipe. `DATE`
*waktu*
Kolom tipe data `TIME` atau ekspresi yang secara implisit mengevaluasi tipe. `TIME`
*jadwal*
Kolom tipe data `TIMETZ` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMETZ`
## Jenis pengembalian
*TIMESTAMP jika masukan adalah *tanggal\$1waktu*.*
*TIMESTAMPTZ jika masukan adalah *tanggal* \$1 jadwal.*
## Contoh
### Contoh pengaturan
Untuk mengatur tabel TIME\$1TEST dan TIMETZ\$1TEST yang digunakan dalam contoh, gunakan perintah berikut.
```
create table time_test(time_val time);
insert into time_test values
('20:00:00'),
('00:00:00.5550'),
('00:58:00');
create table timetz_test(timetz_val timetz);
insert into timetz_test values
('04:00:00+00'),
('00:00:00.5550+00'),
('05:58:00+00');
```
### Contoh dengan kolom waktu
Berikut contoh tabel TIME\$1TEST memiliki kolom TIME\$1VAL (tipe TIME) dengan tiga nilai dimasukkan.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Contoh berikut menggabungkan tanggal literal dan kolom TIME\$1VAL.
```
select date '2000-01-02' + time_val as ts from time_test;
ts
---------------------
2000-01-02 20:00:00
2000-01-02 00:00:00.5550
2000-01-02 00:58:00
```
Contoh berikut menggabungkan tanggal literal dan literal waktu.
```
select date '2000-01-01' + time '20:00:00' as ts;
ts
---------------------
2000-01-01 20:00:00
```
Contoh berikut menggabungkan literal waktu dan tanggal literal.
```
select time '20:00:00' + date '2000-01-01' as ts;
ts
---------------------
2000-01-01 20:00:00
```
### Contoh dengan kolom TIMETZ
Contoh tabel berikut TIMETZ\$1TEST memiliki kolom TIMETZ\$1VAL (tipe TIMETZ) dengan tiga nilai dimasukkan.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Contoh berikut menggabungkan tanggal literal dan kolom TIMETZ\$1VAL.
```
select date '2000-01-01' + timetz_val as ts from timetz_test;
ts
---------------------
2000-01-01 04:00:00+00
2000-01-01 00:00:00.5550+00
2000-01-01 05:58:00+00
```
Contoh berikut menggabungkan kolom TIMETZ\$1VAL dan tanggal literal.
```
select timetz_val + date '2000-01-01' as ts from timetz_test;
ts
---------------------
2000-01-01 04:00:00+00
2000-01-01 00:00:00.5550+00
2000-01-01 05:58:00+00
```
Contoh berikut menggabungkan literal DATE dan literal TIMETZ. Contoh mengembalikan TIMESTAMPTZ yang berada di zona waktu UTC secara default. UTC adalah 8 jam di depan PST, jadi hasilnya 8 jam lebih awal dari waktu input.
```
select date '2000-01-01' + timetz '20:00:00 PST' as ts;
ts
------------------------
2000-01-02 04:00:00+00
```
# Fungsi ADD\$1MONTHS
ADD\$1MONTHS menambahkan jumlah bulan yang ditentukan ke nilai atau ekspresi tanggal atau stempel waktu. [DATEADD](r_DATEADD_function.md)Fungsi ini menyediakan fungsionalitas serupa.
## Sintaksis
```
ADD_MONTHS( {date | timestamp}, integer)
```
## Argumen
*tanggal* \$1 *stempel* waktu
Kolom tipe data `DATE` atau `TIMESTAMP` atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `DATE` `TIMESTAMP` Jika tanggal adalah hari terakhir bulan itu, atau jika bulan yang dihasilkan lebih pendek, fungsi mengembalikan hari terakhir bulan dalam hasilnya. Untuk tanggal lain, hasilnya berisi nomor hari yang sama dengan ekspresi tanggal.
*bilangan bulat*
Nilai tipe data`INTEGER`. Gunakan angka negatif untuk mengurangi bulan dari tanggal.
## Jenis pengembalian
TIMESTAMP
## Contoh
Query berikut menggunakan fungsi ADD\$1MONTHS di dalam fungsi TRUNC. Fungsi TRUNC menghapus waktu hari dari hasil ADD\$1MONTHS. Fungsi ADD\$1MONTHS menambahkan 12 bulan ke setiap nilai dari kolom CALDATE. Nilai dalam kolom CALDATE adalah tanggal.
```
select distinct trunc(add_months(caldate, 12)) as calplus12,
trunc(caldate) as cal
from date
order by 1 asc;
calplus12 | cal
------------+------------
2009-01-01 | 2008-01-01
2009-01-02 | 2008-01-02
2009-01-03 | 2008-01-03
...
(365 rows)
```
*Contoh berikut menggunakan fungsi ADD\$1MONTHS untuk menambahkan 1 bulan ke stempel waktu.*
```
select add_months('2008-01-01 05:07:30', 1);
add_months
---------------------
2008-02-01 05:07:30
```
Contoh berikut menunjukkan perilaku ketika fungsi ADD\$1MONTHS beroperasi pada tanggal dengan bulan yang memiliki jumlah hari yang berbeda. Contoh ini menunjukkan bagaimana fungsi menangani penambahan 1 bulan ke 31 Maret dan menambahkan 1 bulan ke 30 April. April memiliki 30 hari, jadi menambahkan 1 bulan ke 31 Maret menghasilkan 30 April. Mei memiliki 31 hari, jadi menambahkan 1 bulan ke 30 April menghasilkan 31 Mei.
```
select add_months('2008-03-31',1);
add_months
---------------------
2008-04-30 00:00:00
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
```
# Fungsi AT TIME ZONE
AT TIME ZONE menentukan zona waktu mana yang akan digunakan dengan ekspresi TIMESTAMP atau TIMESTAMPTZ.
## Sintaksis
```
AT TIME ZONE 'timezone'
```
## Argumen
*zona waktu*
`TIMEZONE`Untuk nilai pengembalian. Zona waktu dapat ditentukan sebagai nama zona waktu (seperti **'Africa/Kampala'** atau**'Singapore'**) atau sebagai singkatan zona waktu (seperti **'UTC'** atau**'PDT'**).
Untuk melihat daftar nama zona waktu yang didukung, jalankan perintah berikut.
```
select pg_timezone_names();
```
Untuk melihat daftar singkatan zona waktu yang didukung, jalankan perintah berikut.
```
select pg_timezone_abbrevs();
```
Untuk informasi selengkapnya dan contoh tambahan, lihat [Catatan penggunaan zona waktu](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes).
## Jenis pengembalian
TIMESTAMPTZ bila digunakan dengan ekspresi TIMESTAMP. TIMESTAMP bila digunakan dengan ekspresi TIMESTAMPTZ.
## Contoh
Contoh berikut mengkonversi nilai timestamp tanpa zona waktu dan menafsirkannya sebagai waktu MST (UTC\$17 di POSIX). Contoh mengembalikan nilai tipe data TIMESTAMPTZ untuk zona waktu UTC. Jika Anda mengonfigurasi zona waktu default ke zona waktu selain UTC, Anda mungkin melihat hasil yang berbeda.
```
SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-17 03:38:40+00
```
Contoh berikut mengambil timestamp masukan dengan nilai zona waktu di mana zona waktu yang ditentukan adalah EST (UTC\$15 di POSIX) dan mengubahnya menjadi MST (UTC\$17 di POSIX). Contoh mengembalikan nilai tipe data TIMESTAMP.
```
SELECT TIMESTAMPTZ '2001-02-16 20:38:40-05' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-16 18:38:40
```
# Fungsi CONVERT\$1TIMEZONE
CONVERT\$1TIMEZONE mengonversi stempel waktu dari satu zona waktu ke zona waktu lainnya. Fungsi ini secara otomatis menyesuaikan waktu musim panas.
## Sintaksis
```
CONVERT_TIMEZONE( ['source_timezone',] 'target_timezone', 'timestamp')
```
## Argumen
*source\$1timezone*
(Opsional) Zona waktu stempel waktu saat ini. Defaultnya adalah UTC. Untuk informasi selengkapnya, lihat [Catatan penggunaan zona waktu](#CONVERT_TIMEZONE-usage-notes).
*target\$1zona waktu*
Zona waktu untuk stempel waktu baru. Untuk informasi selengkapnya, lihat [Catatan penggunaan zona waktu](#CONVERT_TIMEZONE-usage-notes).
*stempel waktu*
Kolom timestamp atau ekspresi yang secara implisit mengkonversi ke stempel waktu.
## Jenis pengembalian
TIMESTAMP
## Catatan penggunaan zona waktu
*source\$1timezone* atau *target\$1timezone* dapat ditentukan sebagai nama zona waktu (seperti 'Afrika/Kampala' atau 'Singapura') atau sebagai singkatan zona waktu (seperti 'UTC' atau 'PDT'). Anda tidak perlu mengubah nama zona waktu menjadi nama atau singkatan menjadi singkatan. Misalnya, Anda dapat memilih stempel waktu dari nama zona waktu sumber 'Singapura' dan mengubahnya menjadi stempel waktu dalam singkatan zona waktu 'PDT'.
**catatan**
Hasil penggunaan nama zona waktu atau singkatan zona waktu dapat berbeda karena waktu musiman lokal, seperti waktu musim panas.
### Menggunakan nama zona waktu
Untuk melihat daftar nama zona waktu saat ini dan lengkap, jalankan perintah berikut.
```
select pg_timezone_names();
```
Setiap baris berisi string yang dipisahkan koma dengan nama zona waktu, singkatan, offset UTC, dan indikator jika zona waktu mengamati waktu musim panas (atau). `t` `f` Misalnya, cuplikan berikut menunjukkan dua baris yang dihasilkan. Baris pertama adalah zona waktu`Antarctica/South Pole`, singkatan`NZDT`, dengan `13:00:00` offset dari UTC, dan `f` untuk menunjukkan itu tidak mengamati waktu musim panas. Baris kedua adalah zona waktu`Europe/Paris`, singkatan`CET`, dengan `01:00:00` offset dari UTC, dan `f` untuk menunjukkan itu mengamati waktu musim panas.
```
pg_timezone_names
------------------
(Antarctica/South_Pole,NZDT,13:00:00,t)
(Europe/Paris,CET,01:00:00,f)
```
Jalankan pernyataan SQL untuk mendapatkan seluruh daftar dan menemukan nama zona waktu. Sekitar 600 baris dikembalikan. Meskipun beberapa nama zona waktu yang dikembalikan adalah inisialisme atau akronim yang dikapitalisasi (misalnya; GB, RRC, ROK), fungsi CONVERT\$1TIMEZONE memperlakukannya sebagai nama zona waktu, bukan singkatan zona waktu.
*Jika Anda menentukan zona waktu menggunakan nama zona waktu, CONVERT\$1TIMEZONE secara otomatis menyesuaikan waktu musim panas (DST), atau protokol musiman lokal lainnya, seperti Waktu Musim Panas, Waktu Standar, atau Waktu Musim Dingin, yang berlaku untuk zona waktu tersebut selama tanggal dan waktu yang ditentukan oleh 'stempel waktu'.* Misalnya, 'Eropa/London' mewakili UTC di musim dingin dan menambahkan satu jam di musim panas. Perhatikan bahwa Amazon Redshift menggunakan [Database Zona Waktu IANA sebagai sumber otoritatif spesifikasi zona waktu](https://www.iana.org/time-zones).
### Menggunakan singkatan zona waktu
Untuk melihat daftar singkatan zona waktu saat ini dan lengkap, jalankan perintah berikut.
```
select pg_timezone_abbrevs();
```
Hasilnya berisi string yang dipisahkan koma dengan singkatan zona waktu, offset UTC, dan indikator jika zona waktu mengamati waktu musim panas (atau). `t` `f` Misalnya, cuplikan berikut menunjukkan dua baris yang dihasilkan. Baris pertama berisi singkatan untuk Pacific Daylight Time`PDT`, dengan `-07:00:00` offset dari UTC, dan `t` untuk menunjukkan itu mengamati waktu musim panas. Baris kedua berisi singkatan untuk Waktu Standar Pasifik`PST`, dengan `-08:00:00` offset dari UTC, dan `f` untuk menunjukkan itu tidak mengamati waktu musim panas.
```
pg_timezone_abbrevs
--------------------
(PDT,-07:00:00,t)
(PST,-08:00:00,f)
```
Jalankan pernyataan SQL untuk mendapatkan seluruh daftar dan temukan singkatan berdasarkan indikator offset dan daylight saving time. Sekitar 200 baris dikembalikan.
Singkatan zona waktu mewakili offset tetap dari UTC. Jika Anda menentukan zona waktu menggunakan singkatan zona waktu, CONVERT\$1TIMEZONE menggunakan offset tetap dari UTC dan tidak menyesuaikan protokol musiman lokal apa pun.
### Menggunakan format bergaya POSIX
Spesifikasi zona waktu gaya POSIX adalah dalam bentuk *STDoffset*atau *STDoffsetDST*, di mana *STD* adalah singkatan zona waktu, offset adalah *offset* numerik dalam jam barat dari UTC, dan *DST* adalah singkatan zona musim panas opsional. Daylight saving time diasumsikan satu jam lebih cepat dari offset yang diberikan.
Format zona waktu bergaya POSIX menggunakan offset positif di sebelah barat Greenwich, berbeda dengan konvensi ISO-8601, yang menggunakan offset positif di timur Greenwich.
Berikut ini adalah contoh zona waktu bergaya POSIX:
+ PST8
+ PST8PDT
+ EST5
+ EST5EDT
**catatan**
Amazon Redshift tidak memvalidasi spesifikasi zona waktu gaya POSIX, sehingga dimungkinkan untuk mengatur zona waktu ke nilai yang tidak valid. Misalnya, perintah berikut tidak mengembalikan kesalahan, meskipun menetapkan zona waktu ke nilai yang tidak valid.
```
set timezone to ‘xxx36’;
```
## Contoh
Banyak contoh menggunakan kumpulan data sampel TICKIT. Untuk informasi selengkapnya, lihat [Contoh database](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
Contoh berikut mengkonversi nilai timestamp dari zona waktu UTC default untuk PST.
```
select convert_timezone('PST', '2008-08-21 07:23:54');
convert_timezone
------------------------
2008-08-20 23:23:54
```
Contoh berikut mengkonversi nilai timestamp dalam kolom LISTTIME dari zona waktu UTC default ke PST. Meskipun stempel waktu berada dalam periode waktu siang hari, itu diubah menjadi waktu standar karena zona waktu target ditentukan sebagai singkatan (PST).
```
select listtime, convert_timezone('PST', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+-------------------
2008-08-24 09:36:12 2008-08-24 01:36:12
```
Contoh berikut mengonversi timestamp kolom LISTTIME dari zona waktu UTC default ke zona waktu. US/Pacific Zona waktu target menggunakan nama zona waktu, dan stempel waktu berada dalam periode waktu siang hari, sehingga fungsi mengembalikan waktu siang hari.
```
select listtime, convert_timezone('US/Pacific', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+---------------------
2008-08-24 09:36:12 | 2008-08-24 02:36:12
```
Contoh berikut mengkonversi string timestamp dari EST ke PST:
```
select convert_timezone('EST', 'PST', '20080305 12:25:29');
convert_timezone
-------------------
2008-03-05 09:25:29
```
Contoh berikut mengubah stempel waktu ke Waktu Standar Timur AS karena zona waktu target menggunakan nama zona waktu (America/New\$1York) dan stempel waktu berada dalam periode waktu standar.
```
select convert_timezone('America/New_York', '2013-02-01 08:00:00');
convert_timezone
---------------------
2013-02-01 03:00:00
(1 row)
```
Contoh berikut mengubah stempel waktu menjadi US Eastern Daylight Time karena zona waktu target menggunakan nama zona waktu (America/New\$1York) dan stempel waktu berada dalam periode waktu siang hari.
```
select convert_timezone('America/New_York', '2013-06-01 08:00:00');
convert_timezone
---------------------
2013-06-01 04:00:00
(1 row)
```
Contoh berikut menunjukkan penggunaan offset.
```
SELECT CONVERT_TIMEZONE('GMT','NEWZONE +2','2014-05-17 12:00:00') as newzone_plus_2,
CONVERT_TIMEZONE('GMT','NEWZONE-2:15','2014-05-17 12:00:00') as newzone_minus_2_15,
CONVERT_TIMEZONE('GMT','America/Los_Angeles+2','2014-05-17 12:00:00') as la_plus_2,
CONVERT_TIMEZONE('GMT','GMT+2','2014-05-17 12:00:00') as gmt_plus_2;
newzone_plus_2 | newzone_minus_2_15 | la_plus_2 | gmt_plus_2
---------------------+---------------------+---------------------+---------------------
2014-05-17 10:00:00 | 2014-05-17 14:15:00 | 2014-05-17 10:00:00 | 2014-05-17 10:00:00
(1 row)
```
# Fungsi CURRENT\$1DATE
CURRENT\$1DATE mengembalikan tanggal di zona waktu sesi saat ini (UTC secara default) dalam format default:. YYYY-MM-DD
**catatan**
CURRENT\$1DATE mengembalikan tanggal mulai untuk transaksi saat ini, bukan untuk awal pernyataan saat ini. Pertimbangkan skenario di mana Anda memulai transaksi yang berisi beberapa pernyataan pada 10/01/08 23:59, dan pernyataan yang berisi CURRENT\$1DATE berjalan pada 10/02/08 00:00. CURRENT\$1DATE kembali`10/01/08`, tidak. `10/02/08`
## Sintaksis
```
CURRENT_DATE
```
## Jenis pengembalian
DATE
## Contoh
Contoh berikut mengembalikan tanggal saat ini (di Wilayah AWS mana fungsi berjalan).
```
select current_date;
date
------------
2008-10-01
```
Contoh berikut membuat tabel, menyisipkan baris di mana default kolom `todays_date` adalah CURRENT\$1DATE, dan kemudian memilih semua baris dalam tabel.
```
CREATE TABLE insert_dates(
label varchar(128) NOT NULL,
todays_date DATE DEFAULT CURRENT_DATE);
INSERT INTO insert_dates(label)
VALUES('Date row inserted');
SELECT * FROM insert_dates;
label | todays_date
------------------+-------------
Date row inserted | 2023-05-10
```
# Fungsi DATE\$1CMP
DATE\$1CMP membandingkan dua tanggal. Fungsi kembali `0` jika tanggal identik, `1` jika *date1* lebih besar, dan `-1` jika *date2* lebih besar.
## Sintaksis
```
DATE_CMP(date1, date2)
```
## Argumen
*tanggal1*
Kolom tipe data `DATE` atau ekspresi yang mengevaluasi `DATE` tipe.
*tanggal2*
Kolom tipe data `DATE` atau ekspresi yang mengevaluasi `DATE` tipe.
## Jenis pengembalian
INTEGER
## Contoh
Kueri berikut membandingkan nilai DATE di kolom CALDATE dengan tanggal 4 Januari 2008 dan mengembalikan apakah nilai di CALDATE adalah sebelum (`-1`), sama dengan (), atau setelah (`0``1`) 4 Januari 2008:
```
select caldate, '2008-01-04',
date_cmp(caldate,'2008-01-04')
from date
order by dateid
limit 10;
caldate | ?column? | date_cmp
-----------+------------+----------
2008-01-01 | 2008-01-04 | -1
2008-01-02 | 2008-01-04 | -1
2008-01-03 | 2008-01-04 | -1
2008-01-04 | 2008-01-04 | 0
2008-01-05 | 2008-01-04 | 1
2008-01-06 | 2008-01-04 | 1
2008-01-07 | 2008-01-04 | 1
2008-01-08 | 2008-01-04 | 1
2008-01-09 | 2008-01-04 | 1
2008-01-10 | 2008-01-04 | 1
(10 rows)
```
# Fungsi DATE\$1CMP\$1TIMESTAMP
**DATE\$1CMP\$1TIMESTAMP membandingkan tanggal dengan stempel waktu dan mengembalikan `0` jika nilainya identik, jika tanggal lebih besar secara kronologis dan jika stempel waktu lebih besar. `1` `-1`**
## Sintaksis
```
DATE_CMP_TIMESTAMP(date, timestamp)
```
## Argumen
*tanggal*
Kolom tipe data `DATE` atau ekspresi yang mengevaluasi `DATE` tipe.
*stempel waktu*
Kolom tipe data `TIMESTAMP` atau ekspresi yang mengevaluasi `TIMESTAMP` tipe.
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut membandingkan tanggal dengan `2008-06-18` LISTTIME. Nilai kolom LISTTIME adalah stempel waktu. Daftar yang dibuat sebelum tanggal ini kembali`1`; daftar yang dibuat setelah tanggal ini kembali`-1`.
```
select listid, '2008-06-18', listtime,
date_cmp_timestamp('2008-06-18', listtime)
from listing
order by 1, 2, 3, 4
limit 10;
listid | ?column? | listtime | date_cmp_timestamp
--------+------------+---------------------+--------------------
1 | 2008-06-18 | 2008-01-24 06:43:29 | 1
2 | 2008-06-18 | 2008-03-05 12:25:29 | 1
3 | 2008-06-18 | 2008-11-01 07:35:33 | -1
4 | 2008-06-18 | 2008-05-24 01:18:37 | 1
5 | 2008-06-18 | 2008-05-17 02:29:11 | 1
6 | 2008-06-18 | 2008-08-15 02:08:13 | -1
7 | 2008-06-18 | 2008-11-15 09:38:15 | -1
8 | 2008-06-18 | 2008-11-09 05:07:30 | -1
9 | 2008-06-18 | 2008-09-09 08:03:36 | -1
10 | 2008-06-18 | 2008-06-17 09:44:54 | 1
(10 rows)
```
# Fungsi DATE\$1CMP\$1TIMESTAMPTZ
**DATE\$1CMP\$1TIMESTAMPTZ membandingkan tanggal dengan stempel waktu dengan zona waktu dan mengembalikan `0` jika nilainya identik, jika tanggal lebih besar secara kronologis dan jika timestamptz lebih besar. `1` `-1`**
## Sintaksis
```
DATE_CMP_TIMESTAMPTZ(date, timestamptz)
```
## Argumen
*tanggal*
Kolom tipe data `DATE` atau ekspresi yang secara implisit mengevaluasi tipe. `DATE`
*timestamptz*
Kolom tipe data `TIMESTAMPTZ` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMPTZ`
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut membandingkan tanggal dengan `2008-06-18` LISTTIME. Daftar yang dibuat sebelum tanggal ini kembali`1`; daftar yang dibuat setelah tanggal ini kembali`-1`.
```
select listid, '2008-06-18', CAST(listtime AS timestamptz),
date_cmp_timestamptz('2008-06-18', CAST(listtime AS timestamptz))
from listing
order by 1, 2, 3, 4
limit 10;
listid | ?column? | timestamptz | date_cmp_timestamptz
--------+------------+------------------------+----------------------
1 | 2008-06-18 | 2008-01-24 06:43:29+00 | 1
2 | 2008-06-18 | 2008-03-05 12:25:29+00 | 1
3 | 2008-06-18 | 2008-11-01 07:35:33+00 | -1
4 | 2008-06-18 | 2008-05-24 01:18:37+00 | 1
5 | 2008-06-18 | 2008-05-17 02:29:11+00 | 1
6 | 2008-06-18 | 2008-08-15 02:08:13+00 | -1
7 | 2008-06-18 | 2008-11-15 09:38:15+00 | -1
8 | 2008-06-18 | 2008-11-09 05:07:30+00 | -1
9 | 2008-06-18 | 2008-09-09 08:03:36+00 | -1
10 | 2008-06-18 | 2008-06-17 09:44:54+00 | 1
(10 rows)
```
# Fungsi DATEADD
Menambah nilai DATE, TIME, TIMETZ, atau TIMESTAMP dengan interval tertentu.
## Sintaksis
```
DATEADD( datepart, interval, {date|time|timetz|timestamp} )
```
## Argumen
*datepart*
Bagian tanggal (tahun, bulan, hari, atau jam, misalnya) tempat fungsi beroperasi. Untuk informasi selengkapnya, lihat [Bagian tanggal untuk fungsi tanggal atau stempel waktu](r_Dateparts_for_datetime_functions.md).
*interval*
Integer yang menentukan interval (jumlah hari, misalnya) untuk ditambahkan ke ekspresi target. Sebuah integer negatif mengurangi interval.
*tanggal* *\$1 *waktu* \$1 *timetz \$1 stempel waktu**
Kolom TANGGAL, WAKTU, TIMETZ, atau TIMESTAMP atau ekspresi yang secara implisit mengkonversi ke TANGGAL, WAKTU, TIMETZ, atau TIMESTAMP. Ekspresi DATE, TIME, TIMETZ, atau TIMESTAMP harus berisi bagian tanggal yang ditentukan.
## Jenis pengembalian
TIMESTAMP atau TIME atau TIMETZ tergantung pada tipe data input.
## Contoh dengan kolom DATE
Contoh berikut menambahkan 30 hari untuk setiap tanggal di bulan November yang ada di tabel DATE.
```
select dateadd(day,30,caldate) as novplus30
from date
where month='NOV'
order by dateid;
novplus30
---------------------
2008-12-01 00:00:00
2008-12-02 00:00:00
2008-12-03 00:00:00
...
(30 rows)
```
Contoh berikut menambahkan 18 bulan ke nilai tanggal literal.
```
select dateadd(month,18,'2008-02-28');
date_add
---------------------
2009-08-28 00:00:00
(1 row)
```
Nama kolom default untuk fungsi DATEADD adalah DATE\$1ADD. Stempel waktu default untuk nilai tanggal adalah. `00:00:00`
Contoh berikut menambahkan 30 menit ke nilai tanggal yang tidak menentukan stempel waktu.
```
select dateadd(m,30,'2008-02-28');
date_add
---------------------
2008-02-28 00:30:00
(1 row)
```
Anda dapat memberi nama bagian tanggal secara lengkap atau menyingkatnya. Dalam hal ini, *m* berarti menit, bukan bulan.
## Contoh dengan kolom TIME
Berikut contoh tabel TIME\$1TEST memiliki kolom TIME\$1VAL (tipe TIME) dengan tiga nilai dimasukkan.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Contoh berikut menambahkan 5 menit untuk setiap TIME\$1VAL dalam tabel TIME\$1TEST.
```
select dateadd(minute,5,time_val) as minplus5 from time_test;
minplus5
---------------
20:05:00
00:05:00.5550
01:03:00
```
Contoh berikut menambahkan 8 jam ke nilai waktu literal.
```
select dateadd(hour, 8, time '13:24:55');
date_add
---------------
21:24:55
```
Contoh berikut menunjukkan kapan waktu berjalan lebih dari 24:00:00 atau di bawah 00:00:00.
```
select dateadd(hour, 12, time '13:24:55');
date_add
---------------
01:24:55
```
## Contoh dengan kolom TIMETZ
Nilai output dalam contoh ini ada di UTC yang merupakan zona waktu default.
Contoh tabel berikut TIMETZ\$1TEST memiliki kolom TIMETZ\$1VAL (tipe TIMETZ) dengan tiga nilai dimasukkan.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Contoh berikut menambahkan 5 menit untuk setiap TIMETZ\$1VAL dalam tabel TIMETZ\$1TEST.
```
select dateadd(minute,5,timetz_val) as minplus5_tz from timetz_test;
minplus5_tz
---------------
04:05:00+00
00:05:00.5550+00
06:03:00+00
```
Contoh berikut menambahkan 2 jam ke nilai timetz literal.
```
select dateadd(hour, 2, timetz '13:24:55 PST');
date_add
---------------
23:24:55+00
```
## Contoh dengan kolom TIMESTAMP
Nilai output dalam contoh ini ada di UTC yang merupakan zona waktu default.
Contoh tabel berikut TIMESTAMP\$1TEST memiliki kolom TIMESTAMP\$1VAL (tipe TIMESTAMP) dengan tiga nilai disisipkan.
```
SELECT timestamp_val FROM timestamp_test;
timestamp_val
------------------
1988-05-15 10:23:31
2021-03-18 17:20:41
2023-06-02 18:11:12
```
Contoh berikut menambahkan 20 tahun hanya ke nilai TIMESTAMP\$1VAL di TIMESTAMP\$1TEST dari sebelum tahun 2000.
```
SELECT dateadd(year,20,timestamp_val)
FROM timestamp_test
WHERE timestamp_val < to_timestamp('2000-01-01 00:00:00', 'YYYY-MM-DD HH:MI:SS');
date_add
---------------
2008-05-15 10:23:31
```
Contoh berikut menambahkan 5 detik ke nilai stempel waktu literal yang ditulis tanpa indikator detik.
```
SELECT dateadd(second, 5, timestamp '2001-06-06');
date_add
---------------
2001-06-06 00:00:05
```
## Catatan penggunaan
Fungsi DATEADD (bulan,...) dan ADD\$1MONTHS menangani tanggal yang jatuh pada akhir bulan secara berbeda:
+ ADD\$1MONTHS: Jika tanggal yang Anda tambahkan adalah hari terakhir bulan itu, hasilnya selalu hari terakhir dari bulan hasil, terlepas dari panjang bulan. Misalnya, 30 April\$11 bulan adalah 31 Mei.
```
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
(1 row)
```
+ DATEADD: Jika ada lebih sedikit hari pada tanggal yang Anda tambahkan daripada di bulan hasil, hasilnya adalah hari yang sesuai dari bulan hasil, bukan hari terakhir bulan itu. Misalnya, 30 April\$11 bulan adalah 30 Mei.
```
select dateadd(month,1,'2008-04-30');
date_add
---------------------
2008-05-30 00:00:00
(1 row)
```
Fungsi DATEADD menangani tanggal tahun kabisat 02-29 secara berbeda saat menggunakan dateadd (month, 12,...) atau dateadd (year, 1,...).
```
select dateadd(month,12,'2016-02-29');
date_add
---------------------
2017-02-28 00:00:00
select dateadd(year, 1, '2016-02-29');
date_add
---------------------
2017-03-01 00:00:00
```
# Fungsi DATEDIFF
DATEDIFF mengembalikan perbedaan antara bagian tanggal dari dua ekspresi tanggal atau waktu.
## Sintaksis
```
DATEDIFF( datepart, {date|time|timetz|timestamp}, {date|time|timetz|timestamp} )
```
## Argumen
*datepart*
Bagian spesifik dari nilai tanggal atau waktu (tahun, bulan, atau hari, jam, menit, detik, milidetik, atau mikrodetik) tempat fungsi beroperasi. Untuk informasi selengkapnya, lihat [Bagian tanggal untuk fungsi tanggal atau stempel waktu](r_Dateparts_for_datetime_functions.md).
Secara khusus, DATEDIFF menentukan jumlah batas bagian tanggal yang disilangkan antara dua ekspresi. Misalnya, anggaplah Anda menghitung perbedaan tahun antara dua tanggal, `12-31-2008` dan`01-01-2009`. Dalam hal ini, fungsi mengembalikan 1 tahun meskipun fakta bahwa tanggal-tanggal ini hanya terpisah satu hari. Jika Anda menemukan perbedaan jam antara dua stempel waktu, `01-01-2009 8:30:00` dan`01-01-2009 10:00:00`, hasilnya adalah 2 jam. Jika Anda menemukan perbedaan jam antara dua stempel waktu, `8:30:00` dan`10:00:00`, hasilnya adalah 2 jam.
*tanggal* *\$1 *waktu* \$1 *timetz \$1 stempel waktu**
Kolom atau ekspresi TANGGAL, WAKTU, TIMETZ, atau TIMESTAMP yang secara implisit dikonversi ke TANGGAL, WAKTU, TIMETZ, atau TIMESTAMP. Ekspresi harus berisi tanggal atau bagian waktu yang ditentukan. Jika tanggal atau waktu kedua lebih lambat dari tanggal atau waktu pertama, hasilnya positif. Jika tanggal atau waktu kedua lebih awal dari tanggal atau waktu pertama, hasilnya negatif.
## Jenis pengembalian
BIGINT
## Contoh dengan kolom DATE
Contoh berikut menemukan perbedaan, dalam jumlah minggu, antara dua nilai tanggal literal.
```
select datediff(week,'2009-01-01','2009-12-31') as numweeks;
numweeks
----------
52
(1 row)
```
Contoh berikut menemukan perbedaan, dalam jam, antara dua nilai tanggal literal. Ketika Anda tidak memberikan nilai waktu untuk tanggal, defaultnya adalah 00:00:00.
```
select datediff(hour, '2023-01-01', '2023-01-03 05:04:03');
date_diff
----------
53
(1 row)
```
Contoh berikut menemukan perbedaan, dalam hari, antara dua nilai TIMESTAMETZ literal.
```
Select datediff(days, 'Jun 1,2008 09:59:59 EST', 'Jul 4,2008 09:59:59 EST')
date_diff
----------
33
```
Contoh berikut menemukan perbedaan, dalam hari, antara dua tanggal dalam baris tabel yang sama.
```
select * from date_table;
start_date | end_date
-----------+-----------
2009-01-01 | 2009-03-23
2023-01-04 | 2024-05-04
(2 rows)
select datediff(day, start_date, end_date) as duration from date_table;
duration
---------
81
486
(2 rows)
```
Contoh berikut menemukan perbedaan, dalam jumlah kuartal, antara nilai literal di masa lalu dan tanggal hari ini. Contoh ini mengasumsikan bahwa tanggal saat ini adalah 5 Juni 2008. Anda dapat memberi nama bagian tanggal secara lengkap atau menyingkatnya. Nama kolom default untuk fungsi DATEDIFF adalah DATE\$1DIFF.
```
select datediff(qtr, '1998-07-01', current_date);
date_diff
-----------
40
(1 row)
```
Contoh berikut bergabung dengan tabel PENJUALAN dan DAFTAR untuk menghitung berapa hari setelah mereka terdaftar, tiket apa pun dijual untuk daftar 1000 hingga 1005. Penantian terpanjang untuk penjualan daftar ini adalah 15 hari, dan yang terpendek kurang dari satu hari (0 hari).
```
select priceperticket,
datediff(day, listtime, saletime) as wait
from sales, listing where sales.listid = listing.listid
and sales.listid between 1000 and 1005
order by wait desc, priceperticket desc;
priceperticket | wait
---------------+------
96.00 | 15
123.00 | 11
131.00 | 9
123.00 | 6
129.00 | 4
96.00 | 4
96.00 | 0
(7 rows)
```
Contoh ini menghitung jumlah rata-rata jam penjual menunggu semua penjualan tiket.
```
select avg(datediff(hours, listtime, saletime)) as avgwait
from sales, listing
where sales.listid = listing.listid;
avgwait
---------
465
(1 row)
```
## Contoh dengan kolom TIME
Berikut contoh tabel TIME\$1TEST memiliki kolom TIME\$1VAL (tipe TIME) dengan tiga nilai dimasukkan.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Contoh berikut menemukan perbedaan jumlah jam antara kolom TIME\$1VAL dan literal waktu.
```
select datediff(hour, time_val, time '15:24:45') from time_test;
date_diff
-----------
-5
15
15
```
Contoh berikut menemukan perbedaan jumlah menit antara dua nilai waktu literal.
```
select datediff(minute, time '20:00:00', time '21:00:00') as nummins;
nummins
----------
60
```
## Contoh dengan kolom TIMETZ
Contoh tabel berikut TIMETZ\$1TEST memiliki kolom TIMETZ\$1VAL (tipe TIMETZ) dengan tiga nilai dimasukkan.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Contoh berikut menemukan perbedaan jumlah jam, antara literal TIMETZ dan timetz\$1val.
```
select datediff(hours, timetz '20:00:00 PST', timetz_val) as numhours from timetz_test;
numhours
----------
0
-4
1
```
Contoh berikut menemukan perbedaan jumlah jam, antara dua nilai TIMETZ literal.
```
select datediff(hours, timetz '20:00:00 PST', timetz '00:58:00 EST') as numhours;
numhours
----------
1
```
# Fungsi DATE\$1PART
DATE\$1PART mengekstrak nilai bagian tanggal dari ekspresi. DATE\$1PART adalah sinonim dari fungsi PGDATE\$1PART.
## Sintaksis
```
DATE_PART(datepart, {date|timestamp})
```
## Argumen
*datepart*
Pengidentifikasi literal atau string dari bagian tertentu dari nilai tanggal (misalnya, tahun, bulan, atau hari) di mana fungsi beroperasi. Untuk informasi selengkapnya, lihat [Bagian tanggal untuk fungsi tanggal atau stempel waktu](r_Dateparts_for_datetime_functions.md).
\$1*tanggal* \$1 *stempel waktu*\$1
Kolom tanggal, kolom stempel waktu, atau ekspresi yang secara implisit mengkonversi ke tanggal atau stempel waktu. *Kolom atau ekspresi dalam *tanggal* atau *stempel waktu* harus berisi bagian tanggal yang ditentukan dalam datepart.*
## Jenis pengembalian
DOUBLE
## Contoh
Nama kolom default untuk fungsi DATE\$1PART adalah. `pgdate_part`
Untuk informasi selengkapnya tentang data yang digunakan dalam beberapa contoh ini, lihat[Database sampel](c_sampledb.md).
Contoh berikut menemukan menit dari stempel waktu literal.
```
SELECT DATE_PART(minute, timestamp '20230104 04:05:06.789');
pgdate_part
-----------
5
```
Contoh berikut menemukan nomor minggu dari literal stempel waktu. Perhitungan angka minggu mengikuti standar ISO 8601. Untuk informasi lebih lanjut, lihat [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) di Wikipedia.
```
SELECT DATE_PART(week, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
18
```
Contoh berikut menemukan hari dalam sebulan dari stempel waktu literal.
```
SELECT DATE_PART(day, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
2
```
Contoh berikut menemukan hari dalam seminggu dari stempel waktu literal. Perhitungan angka hari dalam seminggu adalah bilangan bulat dari 0-6, dimulai dengan hari Minggu.
```
SELECT DATE_PART(dayofweek, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
1
```
Contoh berikut menemukan abad dari stempel waktu literal. Perhitungan abad mengikuti standar ISO 8601. Untuk informasi lebih lanjut, lihat [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) di Wikipedia.
```
SELECT DATE_PART(century, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
21
```
Contoh berikut menemukan milenium dari literal stempel waktu. Perhitungan milenium mengikuti standar ISO 8601. Untuk informasi lebih lanjut, lihat [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) di Wikipedia.
```
SELECT DATE_PART(millennium, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
3
```
Contoh berikut menemukan mikrodetik dari literal stempel waktu. Perhitungan mikrodetik mengikuti standar ISO 8601. Untuk informasi lebih lanjut, lihat [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) di Wikipedia.
```
SELECT DATE_PART(microsecond, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
789000
```
Contoh berikut menemukan bulan dari tanggal literal.
```
SELECT DATE_PART(month, date '20220502');
pgdate_part
-----------
5
```
Contoh berikut menerapkan fungsi DATE\$1PART ke kolom dalam tabel.
```
SELECT date_part(w, listtime) AS weeks, listtime
FROM listing
WHERE listid=10
weeks | listtime
------+---------------------
25 | 2008-06-17 09:44:54
(1 row)
```
Anda dapat memberi nama bagian tanggal secara lengkap atau menyingkatnya; dalam hal ini, *w* berarti minggu.
Bagian tanggal hari minggu mengembalikan bilangan bulat dari 0-6, dimulai dengan hari Minggu. Gunakan DATE\$1PART dengan dow (DAYOFWEEK) untuk melihat acara pada hari Sabtu.
```
SELECT date_part(dow, starttime) AS dow, starttime
FROM event
WHERE date_part(dow, starttime)=6
ORDER BY 2,1;
dow | starttime
-----+---------------------
6 | 2008-01-05 14:00:00
6 | 2008-01-05 14:00:00
6 | 2008-01-05 14:00:00
6 | 2008-01-05 14:00:00
...
(1147 rows)
```
# Fungsi DATE\$1PART\$1YEAR
Fungsi DATE\$1PART\$1YEAR mengekstrak tahun dari tanggal.
## Sintaksis
```
DATE_PART_YEAR(date)
```
## Pendapat
*tanggal*
Kolom tipe data `DATE` atau ekspresi yang secara implisit mengevaluasi tipe. `DATE`
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut menemukan tahun dari tanggal literal.
```
SELECT DATE_PART_YEAR(date '20220502 04:05:06.789');
date_part_year
---------------
2022
```
Contoh berikut mengekstrak tahun dari kolom CALDATE. Nilai dalam kolom CALDATE adalah tanggal. Untuk informasi selengkapnya tentang data yang digunakan dalam contoh ini, lihat[Database sampel](c_sampledb.md).
```
select caldate, date_part_year(caldate)
from date
order by
dateid limit 10;
caldate | date_part_year
-----------+----------------
2008-01-01 | 2008
2008-01-02 | 2008
2008-01-03 | 2008
2008-01-04 | 2008
2008-01-05 | 2008
2008-01-06 | 2008
2008-01-07 | 2008
2008-01-08 | 2008
2008-01-09 | 2008
2008-01-10 | 2008
(10 rows)
```
# Fungsi DATE\$1TRUNC
Fungsi DATE\$1TRUNC memotong ekspresi stempel waktu atau literal berdasarkan bagian tanggal yang Anda tentukan, seperti jam, hari, atau bulan.
## Sintaksis
```
DATE_TRUNC('datepart', timestamp)
```
## Argumen
*datepart*
Bagian tanggal untuk memotong nilai stempel waktu. *Stempel waktu* *input dipotong sesuai presisi datepart input.* Misalnya, `month` terpotong ke hari pertama bulan itu. Format yang valid adalah sebagai berikut:
+ mikrodetik, mikrodetik
+ milidetik, milidetik
+ kedua, detik
+ menit, menit
+ jam, jam
+ hari, hari
+ minggu, minggu
+ bulan, bulan
+ seperempat, kuartal
+ tahun, tahun
+ dekade, dekade
+ abad, berabad-abad
+ milenium, milenium
Untuk informasi selengkapnya tentang singkatan dari beberapa format, lihat [Bagian tanggal untuk fungsi tanggal atau stempel waktu](r_Dateparts_for_datetime_functions.md)
*stempel waktu*
Kolom timestamp atau ekspresi yang secara implisit mengkonversi ke stempel waktu.
## Jenis pengembalian
TIMESTAMP
## Contoh
Pisahkan stempel waktu masukan ke yang kedua.
```
SELECT DATE_TRUNC('second', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:06
```
Pisahkan stempel waktu masukan ke menit.
```
SELECT DATE_TRUNC('minute', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:00
```
Memangkas stempel waktu input ke jam.
```
SELECT DATE_TRUNC('hour', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:00:00
```
Memangkas stempel waktu masukan ke hari itu.
```
SELECT DATE_TRUNC('day', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 00:00:00
```
Pisahkan stempel waktu masukan ke hari pertama dalam sebulan.
```
SELECT DATE_TRUNC('month', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
Potong stempel waktu input ke hari pertama seperempat.
```
SELECT DATE_TRUNC('quarter', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
Pisahkan stempel waktu masukan ke hari pertama dalam setahun.
```
SELECT DATE_TRUNC('year', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-01-01 00:00:00
```
Potong stempel waktu input ke hari pertama abad.
```
SELECT DATE_TRUNC('millennium', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2001-01-01 00:00:00
```
Pisahkan stempel waktu input ke hari Senin dalam seminggu.
```
select date_trunc('week', TIMESTAMP '20220430 04:05:06.789');
date_trunc
2022-04-25 00:00:00
```
Dalam contoh berikut, fungsi DATE\$1TRUNC menggunakan bagian tanggal 'minggu' untuk mengembalikan tanggal untuk hari Senin setiap minggu.
```
select date_trunc('week', saletime), sum(pricepaid) from sales where
saletime like '2008-09%' group by date_trunc('week', saletime) order by 1;
date_trunc | sum
------------+-------------
2008-09-01 | 2474899
2008-09-08 | 2412354
2008-09-15 | 2364707
2008-09-22 | 2359351
2008-09-29 | 705249
```
# Fungsi EKSTRAK
Fungsi EXTRACT mengembalikan bagian tanggal atau waktu dari nilai TIMESTAMP, TIMESTAMPTZ, TIME, TIMETZ, INTERVAL YEAR TO MONTH, atau INTERVAL DAY TO SECOND. Contohnya termasuk hari, bulan, tahun, jam, menit, detik, milidetik, atau mikrodetik dari stempel waktu.
## Sintaksis
```
EXTRACT(datepart FROM source)
```
## Argumen
*datepart*
Subbidang tanggal atau waktu untuk mengekstrak, seperti hari, bulan, tahun, jam, menit, detik, milidetik, atau mikrodetik. Untuk nilai yang mungkin, lihat[Bagian tanggal untuk fungsi tanggal atau stempel waktu](r_Dateparts_for_datetime_functions.md).
*sumber*
Kolom atau ekspresi yang mengevaluasi tipe data TIMESTAMP, TIMESTAMPTZ, WAKTU, TIMETZ, INTERVAL TAHUN KE BULAN, atau INTERVAL HARI KE KEDUA.
## Jenis pengembalian
INTEGER jika nilai *sumber* mengevaluasi tipe data TIMESTAMP, WAKTU, TIMETZ, INTERVAL TAHUN KE BULAN, atau INTERVAL HARI KE KEDUA.
PRESISI GANDA jika nilai *sumber* mengevaluasi tipe data TIMESTAMPTZ.
## Contoh dengan TIMESTAMP
Contoh berikut menentukan angka minggu untuk penjualan di mana harga yang dibayarkan adalah \$110.000 atau lebih. Contoh ini menggunakan data TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
```
select salesid, extract(week from saletime) as weeknum
from sales
where pricepaid > 9999
order by 2;
salesid | weeknum
--------+---------
159073 | 6
160318 | 8
161723 | 26
```
Contoh berikut mengembalikan nilai menit dari nilai timestamp literal.
```
select extract(minute from timestamp '2009-09-09 12:08:43');
date_part
-----------
8
```
Contoh berikut mengembalikan nilai milidetik dari nilai timestamp literal.
```
select extract(ms from timestamp '2009-09-09 12:08:43.101');
date_part
-----------
101
```
## Contoh dengan TIMESTAMPTZ
Contoh berikut mengembalikan nilai tahun dari nilai timestamptz literal.
```
select extract(year from timestamptz '1.12.1997 07:37:16.00 PST');
date_part
-----------
1997
```
## Contoh dengan waktu
Berikut contoh tabel TIME\$1TEST memiliki kolom TIME\$1VAL (tipe TIME) dengan tiga nilai dimasukkan.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Contoh berikut mengekstrak menit dari setiap time\$1val.
```
select extract(minute from time_val) as minutes from time_test;
minutes
-----------
0
0
58
```
Contoh berikut mengekstrak jam dari setiap time\$1val.
```
select extract(hour from time_val) as hours from time_test;
hours
-----------
20
0
0
```
Contoh berikut mengekstrak milidetik dari nilai literal.
```
select extract(ms from time '18:25:33.123456');
date_part
-----------
123
```
## Contoh dengan TIMETZ
Contoh tabel berikut TIMETZ\$1TEST memiliki kolom TIMETZ\$1VAL (tipe TIMETZ) dengan tiga nilai dimasukkan.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Contoh berikut mengekstrak jam dari setiap timetz\$1val.
```
select extract(hour from timetz_val) as hours from time_test;
hours
-----------
4
0
5
```
Contoh berikut mengekstrak milidetik dari nilai literal. Literal tidak dikonversi ke UTC sebelum ekstraksi diproses.
```
select extract(ms from timetz '18:25:33.123456 EST');
date_part
-----------
123
```
Contoh berikut mengembalikan jam offset zona waktu dari UTC dari nilai timetz literal.
```
select extract(timezone_hour from timetz '1.12.1997 07:37:16.00 PDT');
date_part
-----------
-7
```
## Contoh dengan INTERVAL TAHUN KE BULAN dan INTERVAL HARI KE KEDUA
Contoh berikut mengekstrak bagian hari `1` dari INTERVAL DAY TO SECOND yang mendefinisikan 36 jam, yaitu 1 hari 12 jam.
```
select EXTRACT('days' from INTERVAL '36 hours' DAY TO SECOND)
date_part
------------------
1
```
Contoh berikut mengekstrak bagian bulan `3` dari TAHUN KE BULAN yang mendefinisikan 15 bulan, yaitu 1 tahun 3 bulan.
```
select EXTRACT('month' from INTERVAL '15 months' YEAR TO MONTH)
date_part
------------------
3
```
Contoh berikut mengekstrak bagian bulan `6` dari 30 bulan yaitu 2 tahun 6 bulan.
```
select EXTRACT('month' from INTERVAL '30' MONTH)
date_part
------------------
6
```
Contoh berikut mengekstrak bagian jam `2` dari 50 jam yaitu 2 hari 2 jam.
```
select EXTRACT('hours' from INTERVAL '50' HOUR)
date_part
------------------
2
```
Contoh berikut mengekstrak bagian menit `11` dari 1 jam 11 menit 11.123 detik.
```
select EXTRACT('minute' from INTERVAL '70 minutes 70.123 seconds' MINUTE TO SECOND)
date_part
------------------
11
```
Contoh berikut mengekstrak bagian detik `1.11` dari 1 hari 1 jam 1 menit 1,11 detik.
```
select EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND)
date_part
------------------
1.11
```
Contoh berikut mengekstrak jumlah total jam dalam INTERVAL. Setiap bagian diekstraksi dan ditambahkan ke total.
```
select EXTRACT('days' from INTERVAL '50' HOUR) * 24 + EXTRACT('hours' from INTERVAL '50' HOUR)
?column?
------------------
50
```
Contoh berikut mengekstrak jumlah detik dalam INTERVAL. Setiap bagian diekstraksi dan ditambahkan ke total.
```
select EXTRACT('days' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 86400 +
EXTRACT('hours' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 3600 +
EXTRACT('minutes' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 60 +
EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND)
?column?
------------------
90061.11
```
# fungsi GETDATE
GETDATE mengembalikan tanggal dan waktu saat ini di zona waktu sesi saat ini (UTC secara default). Ini mengembalikan tanggal mulai atau waktu pernyataan saat ini, bahkan ketika itu berada dalam blok transaksi.
## Sintaksis
```
GETDATE()
```
Tanda kurung diperlukan.
## Jenis pengembalian
TIMESTAMP
## Contoh
Contoh berikut menggunakan fungsi GETDATE untuk mengembalikan stempel waktu penuh untuk tanggal saat ini.
```
select getdate();
timestamp
---------------------
2008-12-04 16:10:43
```
Contoh berikut menggunakan fungsi GETDATE di dalam fungsi TRUNC untuk mengembalikan tanggal saat ini tanpa waktu.
```
select trunc(getdate());
trunc
------------
2008-12-04
```
# Fungsi INTERVAL\$1CMP
INTERVAL\$1CMP membandingkan dua interval dan kembali `1` jika interval pertama lebih besar, `-1` jika interval kedua lebih besar, dan `0` jika intervalnya sama. Untuk informasi selengkapnya, lihat [Contoh literal interval tanpa sintaks qualifier](r_interval_literals.md).
## Sintaks
```
INTERVAL_CMP(interval1, interval2)
```
## Argumen
*interval1*
Nilai literal interval.
*interval2*
Nilai literal interval.
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut membandingkan nilai `3 days` to`1 year`.
```
select interval_cmp('3 days','1 year');
interval_cmp
--------------
-1
```
Contoh ini membandingkan nilainya `7 days` dengan. `1 week`
```
select interval_cmp('7 days','1 week');
interval_cmp
--------------
0
```
Contoh berikut membandingkan nilai `1 year` to`3 days`.
```
select interval_cmp('1 year','3 days');
interval_cmp
--------------
1
```
# Fungsi LAST\$1DAY
*LAST\$1DAY mengembalikan tanggal hari terakhir bulan yang berisi tanggal.* Tipe pengembalian selalu DATE, terlepas dari tipe data argumen *tanggal*.
Untuk informasi selengkapnya tentang mengambil bagian tanggal tertentu, lihat[Fungsi DATE\$1TRUNC](r_DATE_TRUNC.md).
## Sintaksis
```
LAST_DAY( { date | timestamp } )
```
## Argumen
*tanggal* \$1 *stempel* waktu
Kolom tipe data `DATE` atau `TIMESTAMP` atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `DATE` `TIMESTAMP`
## Jenis pengembalian
DATE
## Contoh
Contoh berikut mengembalikan tanggal hari terakhir di bulan berjalan.
```
select last_day(sysdate);
last_day
------------
2014-01-31
```
Contoh berikut mengembalikan jumlah tiket yang terjual untuk masing-masing dari 7 hari terakhir dalam sebulan. Nilai dalam kolom SALETIME adalah stempel waktu.
```
select datediff(day, saletime, last_day(saletime)) as "Days Remaining", sum(qtysold)
from sales
where datediff(day, saletime, last_day(saletime)) < 7
group by 1
order by 1;
days remaining | sum
---------------+-------
0 | 10140
1 | 11187
2 | 11515
3 | 11217
4 | 11446
5 | 11708
6 | 10988
(7 rows)
```
# Fungsi MONTHS\$1BETWEEN
MONTHS\$1BETWEEN menentukan jumlah bulan antara dua tanggal.
Jika kencan pertama lebih lambat dari tanggal kedua, hasilnya positif; jika tidak, hasilnya negatif.
Jika salah satu argumen adalah nol, hasilnya adalah NULL.
## Sintaksis
```
MONTHS_BETWEEN( date1, date2 )
```
## Argumen
*tanggal1*
Kolom tipe data `DATE` atau ekspresi yang secara implisit mengevaluasi tipe. `DATE`
*tanggal2*
Kolom tipe data `DATE` atau ekspresi yang secara implisit mengevaluasi tipe. `DATE`
## Jenis pengembalian
FLOAT8
Bagian bilangan bulat dari hasil didasarkan pada perbedaan antara nilai tahun dan bulan dari tanggal. Bagian fraksional dari hasil dihitung dari nilai hari dan stempel waktu tanggal dan mengasumsikan bulan 31 hari.
Jika *date1* dan *date2* keduanya berisi tanggal yang sama dalam sebulan (misalnya, 1/15/14 dan 2/15/14) atau hari terakhir bulan tersebut (misalnya, 8/31/14 dan 9/30/14), maka hasilnya adalah bilangan bulat berdasarkan nilai tahun dan bulan tanggal, terlepas dari apakah bagian stempel waktu cocok, jika ada.
## Contoh
Contoh berikut mengembalikan bulan antara 1/18/1969 dan 3/18/1969.
```
select months_between('1969-01-18', '1969-03-18')
as months;
months
----------
-2
```
Contoh berikut mengembalikan bulan antara 1/18/1969 dan 1/18/1969.
```
select months_between('1969-01-18', '1969-01-18')
as months;
months
----------
0
```
Contoh berikut mengembalikan bulan antara pertunjukan pertama dan terakhir dari suatu acara.
```
select eventname,
min(starttime) as first_show,
max(starttime) as last_show,
months_between(max(starttime),min(starttime)) as month_diff
from event
group by eventname
order by eventname
limit 5;
eventname first_show last_show month_diff
---------------------------------------------------------------------------
.38 Special 2008-01-21 19:30:00.0 2008-12-25 15:00:00.0 11.12
3 Doors Down 2008-01-03 15:00:00.0 2008-12-01 19:30:00.0 10.94
70s Soul Jam 2008-01-16 19:30:00.0 2008-12-07 14:00:00.0 10.7
A Bronx Tale 2008-01-21 19:00:00.0 2008-12-15 15:00:00.0 10.8
A Catered Affair 2008-01-08 19:30:00.0 2008-12-19 19:00:00.0 11.35
```
# fungsi NEXT\$1DAY
NEXT\$1DAY mengembalikan tanggal contoh pertama dari hari tertentu yang lebih lambat dari tanggal yang diberikan.
Jika nilai *hari* adalah hari yang sama dalam seminggu dengan tanggal yang diberikan, kejadian berikutnya dari hari itu dikembalikan.
## Sintaksis
```
NEXT_DAY( { date | timestamp }, day )
```
## Argumen
*tanggal* \$1 *stempel* waktu
Kolom tipe data `DATE` atau `TIMESTAMP` atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `DATE` `TIMESTAMP`
*hari*
Sebuah string yang berisi nama setiap hari. Kapitalisasi tidak masalah.
Nilai yang valid adalah sebagai berikut.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/r_NEXT_DAY.html)
## Jenis pengembalian
DATE
## Contoh
Contoh berikut mengembalikan tanggal Selasa pertama setelah 8/20/2014.
```
select next_day('2014-08-20','Tuesday');
next_day
-----------
2014-08-26
```
Contoh berikut mengembalikan tanggal Selasa pertama setelah 1/1/2008 pukul 5:54:44.
```
select listtime, next_day(listtime, 'Tue') from listing limit 1;
listtime | next_day
--------------------+-----------
2008-01-01 05:54:44 | 2008-01-08
```
Contoh berikut mendapat target tanggal pemasaran untuk kuartal ketiga.
```
select username, (firstname ||' '|| lastname) as name,
eventname, caldate, next_day (caldate, 'Monday') as marketing_target
from sales, date, users, event
where sales.buyerid = users.userid
and sales.eventid = event.eventid
and event.dateid = date.dateid
and date.qtr = 3
order by marketing_target, eventname, name;
username | name | eventname | caldate | marketing_target
----------+-------------------+----------------------+--------------+-------------------
MBO26QSG | Callum Atkinson | .38 Special | 2008-07-06 | 2008-07-07
WCR50YIU | Erasmus Alvarez | A Doll's House | 2008-07-03 | 2008-07-07
CKT70OIE | Hadassah Adkins | Ana Gabriel | 2008-07-06 | 2008-07-07
VVG07OUO | Nathan Abbott | Armando Manzanero | 2008-07-04 | 2008-07-07
GEW77SII | Scarlet Avila | August: Osage County | 2008-07-06 | 2008-07-07
ECR71CVS | Caryn Adkins | Ben Folds | 2008-07-03 | 2008-07-07
KUW82CYU | Kaden Aguilar | Bette Midler | 2008-07-01 | 2008-07-07
WZE78DJZ | Kay Avila | Bette Midler | 2008-07-01 | 2008-07-07
HXY04NVE | Dante Austin | Britney Spears | 2008-07-02 | 2008-07-07
URY81YWF | Wilma Anthony | Britney Spears | 2008-07-02 | 2008-07-07
```
# fungsi SYSDATE
SYSDATE mengembalikan tanggal dan waktu saat ini di zona waktu sesi saat ini (UTC secara default).
**catatan**
SYSDATE mengembalikan tanggal dan waktu mulai untuk transaksi saat ini, bukan untuk dimulainya pernyataan saat ini.
## Sintaksis
```
SYSDATE
```
Fungsi ini tidak memerlukan argumen.
## Jenis pengembalian
TIMESTAMP
## Contoh
Contoh berikut menggunakan fungsi SYSDATE untuk mengembalikan stempel waktu penuh untuk tanggal saat ini.
```
select sysdate;
timestamp
----------------------------
2008-12-04 16:10:43.976353
```
Contoh berikut menggunakan fungsi SYSDATE di dalam fungsi TRUNC untuk mengembalikan tanggal saat ini tanpa waktu.
```
select trunc(sysdate);
trunc
------------
2008-12-04
```
Kueri berikut mengembalikan informasi penjualan untuk tanggal yang berada di antara tanggal ketika kueri dikeluarkan dan tanggal berapa pun 120 hari sebelumnya.
```
select salesid, pricepaid, trunc(saletime) as saletime, trunc(sysdate) as now
from sales
where saletime between trunc(sysdate)-120 and trunc(sysdate)
order by saletime asc;
salesid | pricepaid | saletime | now
---------+-----------+------------+------------
91535 | 670.00 | 2008-08-07 | 2008-12-05
91635 | 365.00 | 2008-08-07 | 2008-12-05
91901 | 1002.00 | 2008-08-07 | 2008-12-05
...
```
# Fungsi TIMEOFDAY
TIMEOFDAY adalah alias khusus yang digunakan untuk mengembalikan hari kerja, tanggal, dan waktu sebagai nilai string. Ia mengembalikan string time of day untuk pernyataan saat ini, bahkan ketika itu berada dalam blok transaksi.
## Sintaksis
```
TIMEOFDAY()
```
## Jenis pengembalian
VARCHAR
## Contoh
Contoh berikut mengembalikan tanggal dan waktu saat ini dengan menggunakan fungsi TIMEOFDAY.
```
select timeofday();
timeofday
------------
Thu Sep 19 22:53:50.333525 2013 UTC
```
# Fungsi TIMESTAMP\$1CMP
Membandingkan nilai dua stempel waktu dan mengembalikan integer. Jika stempel waktu identik, fungsi kembali. `0` Jika stempel waktu pertama lebih besar, fungsi kembali. `1` Jika stempel waktu kedua lebih besar, fungsi kembali. `-1`
## Sintaksis
```
TIMESTAMP_CMP(timestamp1, timestamp2)
```
## Argumen
*stempel waktu1*
Kolom tipe data `TIMESTAMP` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMP`
*stempel waktu2*
Kolom tipe data `TIMESTAMP` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMP`
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut membandingkan stempel waktu dan menunjukkan hasil perbandingan.
```
SELECT TIMESTAMP_CMP('2008-01-24 06:43:29', '2008-01-24 06:43:29'), TIMESTAMP_CMP('2008-01-24 06:43:29', '2008-02-18 02:36:48'), TIMESTAMP_CMP('2008-02-18 02:36:48', '2008-01-24 06:43:29');
timestamp_cmp | timestamp_cmp | timestamp_cmp
---------------+---------------+---------------
0 | -1 | 1
```
Contoh berikut membandingkan LISTTIME dan SALETIME untuk daftar. Nilai untuk TIMESTAMP\$1CMP adalah `-1` untuk semua listing karena stempel waktu untuk penjualan adalah setelah stempel waktu untuk daftar.
```
select listing.listid, listing.listtime,
sales.saletime, timestamp_cmp(listing.listtime, sales.saletime)
from listing, sales
where listing.listid=sales.listid
order by 1, 2, 3, 4
limit 10;
listid | listtime | saletime | timestamp_cmp
--------+---------------------+---------------------+---------------
1 | 2008-01-24 06:43:29 | 2008-02-18 02:36:48 | -1
4 | 2008-05-24 01:18:37 | 2008-06-06 05:00:16 | -1
5 | 2008-05-17 02:29:11 | 2008-06-06 08:26:17 | -1
5 | 2008-05-17 02:29:11 | 2008-06-09 08:38:52 | -1
6 | 2008-08-15 02:08:13 | 2008-08-31 09:17:02 | -1
10 | 2008-06-17 09:44:54 | 2008-06-26 12:56:06 | -1
10 | 2008-06-17 09:44:54 | 2008-07-10 02:12:36 | -1
10 | 2008-06-17 09:44:54 | 2008-07-16 11:59:24 | -1
10 | 2008-06-17 09:44:54 | 2008-07-22 02:23:17 | -1
12 | 2008-07-25 01:45:49 | 2008-08-04 03:06:36 | -1
(10 rows)
```
Contoh ini menunjukkan bahwa TIMESTAMP\$1CMP mengembalikan 0 untuk stempel waktu yang identik:
```
select listid, timestamp_cmp(listtime, listtime)
from listing
order by 1 , 2
limit 10;
listid | timestamp_cmp
--------+---------------
1 | 0
2 | 0
3 | 0
4 | 0
5 | 0
6 | 0
7 | 0
8 | 0
9 | 0
10 | 0
(10 rows)
```
# Fungsi TIMESTAMP\$1CMP\$1DATE
TIMESTAMP\$1CMP\$1DATE membandingkan nilai stempel waktu dan tanggal. Jika nilai stempel waktu dan tanggal identik, fungsi kembali. `0` Jika stempel waktu lebih besar secara kronologis, fungsi kembali. `1` Jika tanggal lebih besar, fungsi kembali`-1`.
## Sintaksis
```
TIMESTAMP_CMP_DATE(timestamp, date)
```
## Argumen
*stempel waktu*
Kolom tipe data `TIMESTAMP` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMP`
*tanggal*
Kolom tipe data `DATE` atau ekspresi yang secara implisit mengevaluasi tipe. `DATE`
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut membandingkan LISTTIME dengan tanggal. `2008-06-18` Daftar yang dibuat setelah tanggal ini kembali`1`; daftar yang dibuat sebelum tanggal ini kembali`-1`. Nilai LISTTIME adalah stempel waktu.
```
select listid, listtime,
timestamp_cmp_date(listtime, '2008-06-18')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | timestamp_cmp_date
--------+---------------------+--------------------
1 | 2008-01-24 06:43:29 | -1
2 | 2008-03-05 12:25:29 | -1
3 | 2008-11-01 07:35:33 | 1
4 | 2008-05-24 01:18:37 | -1
5 | 2008-05-17 02:29:11 | -1
6 | 2008-08-15 02:08:13 | 1
7 | 2008-11-15 09:38:15 | 1
8 | 2008-11-09 05:07:30 | 1
9 | 2008-09-09 08:03:36 | 1
10 | 2008-06-17 09:44:54 | -1
(10 rows)
```
# Fungsi TIMESTAMP\$1CMP\$1TIMESTAMPTZ
TIMESTAMP\$1CMP\$1TIMESTAMPTZ membandingkan nilai ekspresi stempel waktu dengan stempel waktu dengan ekspresi zona waktu. Jika stempel waktu dan stempel waktu dengan nilai zona waktu identik, fungsi kembali. `0` Jika stempel waktu lebih besar secara kronologis, fungsi kembali. `1` Jika stempel waktu dengan zona waktu lebih besar, fungsi kembali. `–1`
## Sintaksis
```
TIMESTAMP_CMP_TIMESTAMPTZ(timestamp, timestamptz)
```
## Argumen
*stempel waktu*
Kolom tipe data `TIMESTAMP` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMP`
*timestamptz*
Kolom tipe data `TIMESTAMPTZ` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMPTZ`
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut membandingkan stempel waktu dengan stempel waktu dengan zona waktu dan menunjukkan hasil perbandingan.
```
SELECT TIMESTAMP_CMP_TIMESTAMPTZ('2008-01-24 06:43:29', '2008-01-24 06:43:29+00'), TIMESTAMP_CMP_TIMESTAMPTZ('2008-01-24 06:43:29', '2008-02-18 02:36:48+00'), TIMESTAMP_CMP_TIMESTAMPTZ('2008-02-18 02:36:48', '2008-01-24 06:43:29+00');
timestamp_cmp_timestamptz | timestamp_cmp_timestamptz | timestamp_cmp_timestamptz
---------------------------+---------------------------+--------------------------
0 | -1 | 1
```
# Fungsi TIMESTAMPTZ\$1CMP
TIMESTAMPTZ\$1CMP membandingkan nilai dua timestamp dengan nilai zona waktu dan mengembalikan bilangan bulat. Jika stempel waktu identik, fungsi kembali. `0` Jika stempel waktu pertama lebih besar secara kronologis, fungsi akan kembali. `1` Jika stempel waktu kedua lebih besar, fungsi kembali. `–1`
## Sintaksis
```
TIMESTAMPTZ_CMP(timestamptz1, timestamptz2)
```
## Argumen
*stempel waktuz1*
Kolom tipe data `TIMESTAMPTZ` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMPTZ`
*stempel waktu*
Kolom tipe data `TIMESTAMPTZ` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMPTZ`
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut membandingkan stempel waktu dengan zona waktu dan menunjukkan hasil perbandingan.
```
SELECT TIMESTAMPTZ_CMP('2008-01-24 06:43:29+00', '2008-01-24 06:43:29+00'), TIMESTAMPTZ_CMP('2008-01-24 06:43:29+00', '2008-02-18 02:36:48+00'), TIMESTAMPTZ_CMP('2008-02-18 02:36:48+00', '2008-01-24 06:43:29+00');
timestamptz_cmp | timestamptz_cmp | timestamptz_cmp
-----------------+-----------------+----------------
0 | -1 | 1
```
# Fungsi TIMESTAMPTZ\$1CMP\$1DATE
TIMESTAMPTZ\$1CMP\$1DATE membandingkan nilai stempel waktu dan tanggal. Jika nilai stempel waktu dan tanggal identik, fungsi kembali. `0` Jika stempel waktu lebih besar secara kronologis, fungsi kembali. `1` Jika tanggal lebih besar, fungsi kembali`–1`.
## Sintaksis
```
TIMESTAMPTZ_CMP_DATE(timestamptz, date)
```
## Argumen
*timestamptz*
Kolom tipe data `TIMESTAMPTZ` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMPTZ`
*tanggal*
Kolom tipe data `DATE` atau ekspresi yang secara implisit mengevaluasi tipe. `DATE`
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut membandingkan LISTTIME sebagai stempel waktu dengan zona waktu dengan tanggal. `2008-06-18` Daftar yang dibuat setelah tanggal ini kembali`1`; daftar yang dibuat sebelum tanggal ini kembali`-1`.
```
select listid, CAST(listtime as timestamptz) as tstz,
timestamp_cmp_date(tstz, '2008-06-18')
from listing
order by 1, 2, 3
limit 10;
listid | tstz | timestamptz_cmp_date
--------+------------------------+----------------------
1 | 2008-01-24 06:43:29+00 | -1
2 | 2008-03-05 12:25:29+00 | -1
3 | 2008-11-01 07:35:33+00 | 1
4 | 2008-05-24 01:18:37+00 | -1
5 | 2008-05-17 02:29:11+00 | -1
6 | 2008-08-15 02:08:13+00 | 1
7 | 2008-11-15 09:38:15+00 | 1
8 | 2008-11-09 05:07:30+00 | 1
9 | 2008-09-09 08:03:36+00 | 1
10 | 2008-06-17 09:44:54+00 | -1
(10 rows)
```
# Fungsi TIMESTAMPTZ\$1CMP\$1TIMESTAMP
TIMESTAMPTZ\$1CMP\$1TIMESTAMP membandingkan nilai stempel waktu dengan ekspresi zona waktu dengan ekspresi stempel waktu. Jika stempel waktu dengan zona waktu dan nilai timestamp identik, fungsi kembali. `0` Jika stempel waktu dengan zona waktu lebih besar secara kronologis, fungsi kembali. `1` Jika stempel waktu lebih besar, fungsi kembali. `–1`
## Sintaksis
```
TIMESTAMPTZ_CMP_TIMESTAMP(timestamptz, timestamp)
```
## Argumen
*timestamptz*
Kolom tipe data `TIMESTAMPTZ` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMPTZ`
*stempel waktu*
Kolom tipe data `TIMESTAMP` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMP`
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut membandingkan stempel waktu dengan zona waktu dengan stempel waktu dan menunjukkan hasil perbandingan.
```
SELECT TIMESTAMPTZ_CMP_TIMESTAMP('2008-01-24 06:43:29+00', '2008-01-24 06:43:29'), TIMESTAMPTZ_CMP_TIMESTAMP('2008-01-24 06:43:29+00', '2008-02-18 02:36:48'), TIMESTAMPTZ_CMP_TIMESTAMP('2008-02-18 02:36:48+00', '2008-01-24 06:43:29');
timestamptz_cmp_timestamp | timestamptz_cmp_timestamp | timestamptz_cmp_timestamp
---------------------------+---------------------------+---------------------------
0 | -1 | 1
```
# Fungsi TIMEZONE
TIMEZONE mengembalikan timestamp untuk zona waktu tertentu dan nilai timestamp.
Untuk informasi dan contoh tentang cara mengatur zona waktu, lihat[timezone](r_timezone_config.md).
Untuk informasi dan contoh tentang cara mengonversi zona waktu, lihat[CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md).
## Sintaksis
```
TIMEZONE('timezone', { timestamp | timestamptz })
```
## Argumen
*zona waktu*
Zona waktu untuk nilai kembali. Zona waktu dapat ditentukan sebagai nama zona waktu (seperti **'Africa/Kampala'** atau**'Singapore'**) atau sebagai singkatan zona waktu (seperti **'UTC'** atau**'PDT'**). Untuk melihat daftar nama zona waktu yang didukung, jalankan perintah berikut.
```
select pg_timezone_names();
```
Untuk melihat daftar singkatan zona waktu yang didukung, jalankan perintah berikut.
```
select pg_timezone_abbrevs();
```
Perhatikan bahwa Amazon Redshift menggunakan [Database Zona Waktu IANA sebagai sumber otoritatif spesifikasi zona waktu](https://www.iana.org/time-zones). Untuk informasi selengkapnya dan contoh tambahan, lihat [Catatan penggunaan zona waktu](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes).
**stempel waktu \$1 timestamptz**
Ekspresi yang menghasilkan tipe TIMESTAMP atau TIMESTAMPTZ, atau nilai yang secara implisit dapat dipaksa ke stempel waktu atau stempel waktu dengan zona waktu.
## Jenis pengembalian
TIMESTAMPTZ bila digunakan dengan ekspresi TIMESTAMP.
TIMESTAMP bila digunakan dengan ekspresi TIMESTAMPTZ.
## Contoh
Berikut ini mengembalikan timestamp untuk zona waktu UTC menggunakan timestamp `2008-06-17 09:44:54` dari zona waktu PST.
```
SELECT TIMEZONE('PST', '2008-06-17 09:44:54');
timezone
-----------------------
2008-06-17 17:44:54+00
```
Berikut ini mengembalikan timestamp untuk zona waktu PST menggunakan timestamp dengan zona waktu UTC. `2008-06-17 09:44:54+00`
```
SELECT TIMEZONE('PST', timestamptz('2008-06-17 09:44:54+00'));
timezone
-----------------------
2008-06-17 01:44:54
```
# Fungsi TO\$1TIMESTAMP
TO\$1TIMESTAMP mengonversi string TIMESTAMP ke TIMESTAMPTZ. Untuk daftar fungsi tanggal dan waktu tambahan untuk Amazon Redshift, lihat. [Fungsi tanggal dan waktu](Date_functions_header.md)
## Sintaksis
```
to_timestamp(timestamp, format)
```
```
to_timestamp (timestamp, format, is_strict)
```
## Argumen
*stempel waktu*
*Sebuah string yang mewakili nilai timestamp dalam format yang ditentukan oleh format.* Jika argumen ini dibiarkan kosong, nilai stempel waktu defaultnya. `0001-01-01 00:00:00`
*format*
Sebuah string literal yang mendefinisikan format nilai *timestamp*. Format yang menyertakan zona waktu (**TZ**,**tz**, atau**OF**) tidak didukung sebagai input. Untuk format stempel waktu yang valid, lihat. [String format datetime](r_FORMAT_strings.md)
*is\$1strict*
Nilai Boolean opsional yang menentukan apakah kesalahan dikembalikan jika nilai timestamp masukan berada di luar jangkauan. Ketika *is\$1strict* disetel ke TRUE, kesalahan dikembalikan jika ada nilai di luar rentang. Ketika *is\$1strict* disetel ke FALSE, yang merupakan default, maka nilai overflow diterima.
## Jenis pengembalian
TIMESTAMPTZ
## Contoh
Contoh berikut menunjukkan penggunaan fungsi TO\$1TIMESTAMP untuk mengonversi string TIMESTAMP ke TIMESTAMPTZ.
```
select sysdate, to_timestamp(sysdate, 'YYYY-MM-DD HH24:MI:SS') as second;
timestamp | second
-------------------------- ----------------------
2021-04-05 19:27:53.281812 | 2021-04-05 19:27:53+00
```
Dimungkinkan untuk melewatkan TO\$1TIMESTAMP bagian dari tanggal. Bagian tanggal yang tersisa diatur ke nilai default. Waktu termasuk dalam output:
```
SELECT TO_TIMESTAMP('2017','YYYY');
to_timestamp
--------------------------
2017-01-01 00:00:00+00
```
Pernyataan SQL berikut mengonversi string '2011-12-18 24:38:15 'menjadi TIMESTAMPTZ. Hasilnya adalah TIMESTAMPTZ yang jatuh pada hari berikutnya karena jumlah jam lebih dari 24 jam:
```
SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS');
to_timestamp
----------------------
2011-12-19 00:38:15+00
```
Pernyataan SQL berikut mengonversi string '2011-12-18 24:38:15 'menjadi TIMESTAMPTZ. Hasilnya adalah kesalahan karena nilai waktu dalam stempel waktu lebih dari 24 jam:
```
SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS', TRUE);
ERROR: date/time field time value out of range: 24:38:15.0
```
# Fungsi TRUNC
Mempotong a `TIMESTAMP` dan mengembalikan a. `DATE`
Fungsi ini juga dapat memotong angka. Untuk informasi selengkapnya, lihat [Fungsi TRUNC](r_TRUNC.md).
## Sintaks
```
TRUNC(timestamp)
```
## Argumen
*stempel waktu*
Kolom tipe data `TIMESTAMP` atau ekspresi yang secara implisit mengevaluasi tipe. `TIMESTAMP`
Untuk mengembalikan nilai stempel waktu dengan `00:00:00` waktu, lemparkan hasil fungsi ke a. `TIMESTAMP`
## Jenis pengembalian
DATE
## Contoh
Contoh berikut mengembalikan bagian tanggal dari hasil fungsi SYSDATE (yang mengembalikan stempel waktu).
```
SELECT SYSDATE;
+----------------------------+
| timestamp |
+----------------------------+
| 2011-07-21 10:32:38.248109 |
+----------------------------+
SELECT TRUNC(SYSDATE);
+------------+
| trunc |
+------------+
| 2011-07-21 |
+------------+
```
Contoh berikut menerapkan fungsi TRUNC ke kolom. `TIMESTAMP` Jenis pengembalian adalah tanggal.
```
SELECT TRUNC(starttime) FROM event
ORDER BY eventid LIMIT 1;
+------------+
| trunc |
+------------+
| 2008-01-25 |
+------------+
```
Contoh berikut mengembalikan nilai timestamp dengan `00:00:00` sebagai waktu dengan mentransmisikan hasil fungsi TRUNC ke a. `TIMESTAMP`
```
SELECT CAST((TRUNC(SYSDATE)) AS TIMESTAMP);
+---------------------+
| trunc |
+---------------------+
| 2011-07-21 00:00:00 |
+---------------------+
```
# Bagian tanggal untuk fungsi tanggal atau stempel waktu
Tabel berikut mengidentifikasi nama bagian tanggal dan waktu bagian dan singkatan yang diterima sebagai argumen untuk fungsi berikut:
+ DATEADD
+ DATEDIFF
+ DATE\$1PART
+ EKSTRAK
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/r_Dateparts_for_datetime_functions.html)
## Variasi hasil dengan detik, milidetik, dan mikrodetik
Perbedaan kecil dalam hasil kueri terjadi ketika fungsi tanggal yang berbeda menentukan detik, milidetik, atau mikrodetik sebagai bagian tanggal:
+ Fungsi EXTRACT mengembalikan bilangan bulat untuk bagian tanggal yang ditentukan saja, mengabaikan bagian tanggal tingkat yang lebih tinggi dan lebih rendah. Jika bagian tanggal yang ditentukan adalah detik, milidetik dan mikrodetik tidak termasuk dalam hasil. Jika bagian tanggal yang ditentukan adalah milidetik, detik dan mikrodetik tidak termasuk. Jika bagian tanggal yang ditentukan adalah mikrodetik, detik dan milidetik tidak termasuk.
+ Fungsi DATE\$1PART mengembalikan bagian detik lengkap dari stempel waktu, terlepas dari bagian tanggal yang ditentukan, mengembalikan nilai desimal atau bilangan bulat sesuai kebutuhan.
Misalnya, bandingkan hasil kueri berikut:
```
create table seconds(micro timestamp);
insert into seconds values('2009-09-21 11:10:03.189717');
select extract(sec from micro) from seconds;
date_part
-----------
3
select date_part(sec, micro) from seconds;
pgdate_part
-------------
3.189717
```
## Catatan CENTURY, EPOCH, DECADE, dan MIL
CENTURY atau CENTURY
Amazon Redshift menafsirkan CENTURY untuk memulai dengan tahun *\$1\$1 \$11* dan diakhiri dengan tahun: `###0`
```
select extract (century from timestamp '2000-12-16 12:21:13');
date_part
-----------
20
select extract (century from timestamp '2001-12-16 12:21:13');
date_part
-----------
21
```
EPOCH
Implementasi Amazon Redshift EPOCH relatif terhadap 1970-01-01 00:00:00.000 000 terlepas dari zona waktu tempat cluster berada. Anda mungkin perlu mengimbangi hasil dengan perbedaan jam tergantung pada zona waktu di mana cluster berada.
Contoh berikut menunjukkan hal berikut:
1. Membuat tabel bernama EVENT\$1EXAMPLE berdasarkan tabel EVENT. Perintah CREATE AS ini menggunakan fungsi DATE\$1PART untuk membuat kolom tanggal (disebut PGDATE\$1PART secara default) untuk menyimpan nilai epoch untuk setiap peristiwa.
1. Memilih kolom dan tipe data EVENT\$1EXAMPLE dari PG\$1TABLE\$1DEF.
1. Memilih EVENTNAME, STARTTIME, dan PGDATE\$1PART dari tabel EVENT\$1EXAMPLE untuk melihat format tanggal dan waktu yang berbeda.
1. Memilih EVENTNAME dan STARTTIME dari EVENT EXAMPLE apa adanya. Mengkonversi nilai epoch di PGDATE\$1PART menggunakan interval 1 detik ke stempel waktu tanpa zona waktu, dan mengembalikan hasilnya dalam kolom bernama CONVERTED\$1TIMESTAMP.
```
create table event_example
as select eventname, starttime, date_part(epoch, starttime) from event;
select "column", type from pg_table_def where tablename='event_example';
column | type
---------------+-----------------------------
eventname | character varying(200)
starttime | timestamp without time zone
pgdate_part | double precision
(3 rows)
```
```
select eventname, starttime, pgdate_part from event_example;
eventname | starttime | pgdate_part
----------------------+---------------------+-------------
Mamma Mia! | 2008-01-01 20:00:00 | 1199217600
Spring Awakening | 2008-01-01 15:00:00 | 1199199600
Nas | 2008-01-01 14:30:00 | 1199197800
Hannah Montana | 2008-01-01 19:30:00 | 1199215800
K.D. Lang | 2008-01-01 15:00:00 | 1199199600
Spamalot | 2008-01-02 20:00:00 | 1199304000
Macbeth | 2008-01-02 15:00:00 | 1199286000
The Cherry Orchard | 2008-01-02 14:30:00 | 1199284200
Macbeth | 2008-01-02 19:30:00 | 1199302200
Demi Lovato | 2008-01-02 19:30:00 | 1199302200
select eventname,
starttime,
timestamp with time zone 'epoch' + pgdate_part * interval '1 second' AS converted_timestamp
from event_example;
eventname | starttime | converted_timestamp
----------------------+---------------------+---------------------
Mamma Mia! | 2008-01-01 20:00:00 | 2008-01-01 20:00:00
Spring Awakening | 2008-01-01 15:00:00 | 2008-01-01 15:00:00
Nas | 2008-01-01 14:30:00 | 2008-01-01 14:30:00
Hannah Montana | 2008-01-01 19:30:00 | 2008-01-01 19:30:00
K.D. Lang | 2008-01-01 15:00:00 | 2008-01-01 15:00:00
Spamalot | 2008-01-02 20:00:00 | 2008-01-02 20:00:00
Macbeth | 2008-01-02 15:00:00 | 2008-01-02 15:00:00
The Cherry Orchard | 2008-01-02 14:30:00 | 2008-01-02 14:30:00
Macbeth | 2008-01-02 19:30:00 | 2008-01-02 19:30:00
Demi Lovato | 2008-01-02 19:30:00 | 2008-01-02 19:30:00
...
```
DEKADE atau DEKADE
Amazon Redshift menafsirkan DECADE atau DECADECADES DATEPART berdasarkan kalender umum. Misalnya, karena kalender umum dimulai dari tahun 1, dekade pertama (dekade 1) adalah 0001-01-01 hingga 0009-12-31, dan dekade kedua (dekade 2) adalah 0010-01-01 hingga 0019-12-31. Misalnya, dekade 201 membentang dari 2000-01-01 hingga 2009-12-31:
```
select extract(decade from timestamp '1999-02-16 20:38:40');
date_part
-----------
200
select extract(decade from timestamp '2000-02-16 20:38:40');
date_part
-----------
201
select extract(decade from timestamp '2010-02-16 20:38:40');
date_part
-----------
202
```
MIL atau MILS
Amazon Redshift menafsirkan MIL untuk memulai dengan hari pertama tahun *\$1001* dan diakhiri dengan hari terakhir tahun ini: `#000`
```
select extract (mil from timestamp '2000-12-16 12:21:13');
date_part
-----------
2
select extract (mil from timestamp '2001-12-16 12:21:13');
date_part
-----------
3
```