Amazon Redshift は、パッチ 198 以降、新しい Python UDF の作成をサポートしなくなります。既存の Python UDF は、2026 年 6 月 30 日まで引き続き機能します。詳細については、[ブログ記事](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)を参照してください。
# 日付および時刻関数
このセクションでは、Amazon Redshift がサポートする日付と時刻のスカラー関数についての情報を示します。
**Topics**
+ [日付と時刻関数の概要](#date-functions-summary)
+ [トランザクションにおける日付および時刻関数](#date-functions-transactions)
+ [廃止されたリーダーノード専用の関数](#date-functions-deprecated)
+ [\$1 (連結) 演算子](r_DATE-CONCATENATE_function.md)
+ [ADD\$1MONTHS 関数](r_ADD_MONTHS.md)
+ [AT TIME ZONE 関数](r_AT_TIME_ZONE.md)
+ [CONVERT\$1TIMEZONE 関数](CONVERT_TIMEZONE.md)
+ [CURRENT\$1DATE 関数](r_CURRENT_DATE_function.md)
+ [DATE\$1CMP 関数](r_DATE_CMP.md)
+ [DATE\$1CMP\$1TIMESTAMP 関数](r_DATE_CMP_TIMESTAMP.md)
+ [DATE\$1CMP\$1TIMESTAMPTZ 関数](r_DATE_CMP_TIMESTAMPTZ.md)
+ [DATEADD 関数](r_DATEADD_function.md)
+ [DATEDIFF 関数](r_DATEDIFF_function.md)
+ [DATE\$1PART 関数](r_DATE_PART_function.md)
+ [DATE\$1PART\$1YEAR 関数](r_DATE_PART_YEAR.md)
+ [DATE\$1TRUNC 関数](r_DATE_TRUNC.md)
+ [EXTRACT 関数](r_EXTRACT_function.md)
+ [GETDATE 関数](r_GETDATE.md)
+ [INTERVAL\$1CMP 関数](r_INTERVAL_CMP.md)
+ [LAST\$1DAY 関数](r_LAST_DAY.md)
+ [MONTHS\$1BETWEEN 関数](r_MONTHS_BETWEEN_function.md)
+ [NEXT\$1DAY 関数](r_NEXT_DAY.md)
+ [SYSDATE 関数](r_SYSDATE.md)
+ [TIMEOFDAY 関数](r_TIMEOFDAY_function.md)
+ [TIMESTAMP\$1CMP 関数](r_TIMESTAMP_CMP.md)
+ [TIMESTAMP\$1CMP\$1DATE 関数](r_TIMESTAMP_CMP_DATE.md)
+ [TIMESTAMP\$1CMP\$1TIMESTAMPTZ 関数](r_TIMESTAMP_CMP_TIMESTAMPTZ.md)
+ [TIMESTAMPTZ\$1CMP 関数](r_TIMESTAMPTZ_CMP.md)
+ [TIMESTAMPTZ\$1CMP\$1DATE 関数](r_TIMESTAMPTZ_CMP_DATE.md)
+ [TIMESTAMPTZ\$1CMP\$1TIMESTAMP 関数](r_TIMESTAMPTZ_CMP_TIMESTAMP.md)
+ [TIMEZONE 関数](r_TIMEZONE.md)
+ [TO\$1TIMESTAMP 関数](r_TO_TIMESTAMP.md)
+ [TRUNC 関数](r_TRUNC_date.md)
+ [日付関数またはタイムスタンプ関数の日付部分](r_Dateparts_for_datetime_functions.md)
## 日付と時刻関数の概要
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/Date_functions_header.html)
**注記**
うるう秒は経過時間の計算では考慮されません。
## トランザクションにおける日付および時刻関数
トランザクションブロック (BEGIN … END) 内で次の関数を実行すると、関数は現在のステートメントではなく、現在のトランザクションの開始日または開始時刻を返します。
+ SYSDATE
+ TIMESTAMP
+ CURRENT\$1DATE
次の関数は、トランザクションブロック内にある場合でも、現在のステートメントの開始日または開始時刻を常に返します。
+ GETDATE
+ TIMEOFDAY
## 廃止されたリーダーノード専用の関数
次の日付関数は、リーダーノードのみで実行されるため、非推奨となりました。詳細については、「[リーダーノード専用関数](c_SQL_functions_leader_node_only.md)」を参照してください。
+ AGE。代わりに [DATEDIFF 関数](r_DATEDIFF_function.md) を使用します。
+ CURRENT\$1TIME。代わりに [GETDATE 関数](r_GETDATE.md) または [SYSDATE](r_SYSDATE.md) を使用します。
+ CURRENT\$1TIMESTAMP。代わりに [GETDATE 関数](r_GETDATE.md) または [SYSDATE](r_SYSDATE.md) を使用します。
+ LOCALTIME。代わりに [GETDATE 関数](r_GETDATE.md) または [SYSDATE](r_SYSDATE.md) を使用します。
+ LOCALTIMESTAMP。代わりに [GETDATE 関数](r_GETDATE.md) または [SYSDATE](r_SYSDATE.md) を使用します。
+ ISFINITE
+ NOW。代わりに [GETDATE 関数](r_GETDATE.md) または [SYSDATE](r_SYSDATE.md) を使用します。マテリアライズドビュー内で NOW 関数を使用する場合、現在のタイムスタンプではなく、マテリアライズドビューの作成時のタイムスタンプが設定されます。
# \$1 (連結) 演算子
\$1 記号の両側のいずれかの方で DATE を TIME または TIMETZ に連結し、TIMESTAMP または TIMESTAMPTZ を返します。
## 構文
```
date + {time | timetz}
```
引数の順序は逆にすることができます。例: *time* \$1 *date*。
## 引数
*date*
データ型 `DATE` の列または `DATE` 型に暗黙的に評価される式。
*時間*:
データ型 `TIME` の列または `TIME` 型に暗黙的に評価される式。
*timetz*
データ型 `TIMETZ` の列または `TIMETZ` 型に暗黙的に評価される式。
## 戻り型
入力が *date* \$1 *time* の場合は TIMESTAMP です。
入力が *date* \$1 *timetz* の場合は TIMESTAMPTZ です。
## 例
### セットアップ例
例で使用されている TIME\$1TEST テーブルと TIMEZ\$1TEST テーブルをセットアップするには、次のコマンドを使用します。
```
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');
```
### 時間列の例
次のテーブルの TIME\$1TEST の例には、3 つの値が挿入された列 TIME\$1VAL (タイプ TIME) があります。
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
次の例では、日付リテラルと 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
```
次の例では、日付リテラルと時刻リテラルを連結します。
```
select date '2000-01-01' + time '20:00:00' as ts;
ts
---------------------
2000-01-01 20:00:00
```
次の例では、時刻リテラルと日付リテラルを連結します。
```
select time '20:00:00' + date '2000-01-01' as ts;
ts
---------------------
2000-01-01 20:00:00
```
### TIMETZ 列の例
次のテーブルの TIMETZ\$1TEST の例には、3 つの値が挿入された列 TIMETZ\$1VAL (タイプ TIMETZ) があります。
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
次の例では、日付リテラルと 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
```
次の例では、TIMETZ\$1VAL 列と date リテラルを連結します。
```
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
```
次の例では、DATE リテラルと TIMETZ 列を連結します。この例では、デフォルトで UTC タイムゾーンにある TIMESTAMPTZ が返されます。UTC は PST よりも 8 時間進んでいるため、結果は入力時間より 8 時間進みます。
```
select date '2000-01-01' + timetz '20:00:00 PST' as ts;
ts
------------------------
2000-01-02 04:00:00+00
```
# ADD\$1MONTHS 関数
ADD\$1MONTHS は日付またはタイムスタンプの値または式に、指定された月数を加算します。[DATEADD](r_DATEADD_function.md) 関数は同様の機能を提供します。
## 構文
```
ADD_MONTHS( {date | timestamp}, integer)
```
## 引数
*date* \$1 *timestamp*
データ型 `DATE` または `TIMESTAMP` の列、あるいは `DATE` 型または `TIMESTAMP` 型に暗黙的に評価される式。date がその月の最終日である場合、または結果の月が短い場合、関数は結果に月の最終日を返します。その他の日付の場合、結果には date 式と同じ日数が含まれます。
* (整数*)
データ型 `INTEGER` の値。負の数を使用し、日付から月を削除します。
## 戻り型
TIMESTAMP
## 例
次のクエリは、TRUNC 関数内の ADD\$1MONTHS 関数を使用します。TRUNC 関数は、ADD\$1MONTHS の結果から日付の時刻を削除します。ADD\$1MONTHS 関数は CALDATE 列の値ごとに 12 か月を追加します。CALDATE 列の値は日付です。
```
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)
```
次の例では、ADD\$1MONTHS 関数を使用して、*timestamp* に 1 か月を加算しています。
```
select add_months('2008-01-01 05:07:30', 1);
add_months
---------------------
2008-02-01 05:07:30
```
次の例は、ADD\$1MONTHS 関数が異なる日数の月を持つ日付で実行される動作を示しています。この例は、関数が 3 月 31 日への 1 か月の加算と、4 月 30 日への 1 か月の加算をどのように処理するかを示しています。4 月は 30 日間あるので、3 月 31 日に 1 か月を加えると 4 月 30 日になります。5 月は 31 日間あるので、4 月 30 日に 1 か月を加えると 5 月 31 日になります。
```
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
```
# AT TIME ZONE 関数
AT TIME ZONE は、TIMESTAMP 式または TIMESTAMPTZ 式で使用するタイムゾーンを指定します。
## 構文
```
AT TIME ZONE 'timezone'
```
## 引数
*timezone*
戻り値の `TIMEZONE`。タイムゾーンは、タイムゾーン名 (**'Africa/Kampala'** または **'Singapore'** など) またはタイムゾーンの略名 (**'UTC'** または **'PDT'** など) として指定できます。
サポートされるタイムゾーン名のリストを表示するには、次のコマンドを実行します。
```
select pg_timezone_names();
```
サポートされるタイムゾーン省略形のリストを表示するには、次のコマンドを実行します。
```
select pg_timezone_abbrevs();
```
詳細な説明と例については、「[タイムゾーンの使用上の注意](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes)」を参照してください。
## 戻り型
TIMESTAMP 式で使用する場合は TIMESTAMPTZ。TIMESTAMPTZ 式で使用する場合は TIMESTAMP。
## 例
次の例では、タイムゾーンのないタイムゾーン値を変換して MST 時間 (POSIX では UTC\$17) として解釈します。この例では、UTC タイムゾーンのデータ型 TIMESTAMPTZ の値を返します。デフォルトのタイムゾーンを UTC 以外のタイムゾーンに設定すると、異なる結果が表示される場合があります。
```
SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-17 03:38:40+00
```
次の例では、指定されたタイムゾーンが EST (POSIX では UTC\$15) であるタイムゾーン値を持つ入力タイムスタンプを取得し、それを MST (POSIX では UTC\$17) に変換します。この例では、データ型 TIMESTAMP の値を返します。
```
SELECT TIMESTAMPTZ '2001-02-16 20:38:40-05' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-16 18:38:40
```
# CONVERT\$1TIMEZONE 関数
CONVERT\$1TIMEZONE は、タイムスタンプのタイムゾーンを別のタイムゾーンに変換します。この関数は夏時間に合わせて自動的に調整されます。
## 構文
```
CONVERT_TIMEZONE( ['source_timezone',] 'target_timezone', 'timestamp')
```
## 引数
*source\$1timezone*
(オプション) 現在のタイムスタンプのタイムゾーン。デフォルトは UTC です。詳細については、「[タイムゾーンの使用上の注意](#CONVERT_TIMEZONE-usage-notes)」を参照してください。
*target\$1timezone*
新しいタイムスタンプのタイムゾーン。詳細については、「[タイムゾーンの使用上の注意](#CONVERT_TIMEZONE-usage-notes)」を参照してください。
*timestamp*
タイムスタンプの列、あるいは暗黙的にタイムスタンプに変換される式。
## 戻り型
TIMESTAMP
## タイムゾーンの使用上の注意
*source\$1timezone* または *target\$1timezone* のいずれかをタイムゾーン名 (「Africa/Kampala」または「Singapore」など) またはタイムゾーンの略名 (「UTC」または「PDT」など) として指定できます。タイムゾーン名を名前に変換したり、略語を略語に変換したりする必要はありません。例えば、ソースタイムゾーン名「Singapore」からタイムスタンプを選択して、タイムゾーンの略語「PDT」のタイムスタンプに変換できます。
**注記**
タイムゾーン名またはタイムゾーンの略名を使用した結果は、地域の季節ごとの時間 (夏時間など) に応じて異なる場合があります。
### タイムゾーン名の使用
タイムゾーン名の完全なリストの最新版を表示するには、次のコマンドを実行します。
```
select pg_timezone_names();
```
各行には、タイムゾーン名、略名、UTC オフセット、タイムゾーンが夏時間を採用しているかどうかのインジケーター (`t` または `f`) などが、カンマ区切りの文字列で含まれています。例えば、次のスニペットは、結果として 2 行が表示されます。1 番目の行はタイムゾーン `Antarctica/South Pole` で略名は `NZDT`、UTC からのオフセットは `13:00:00` です。`f` によって夏時間が適用されないことが示されています。2 番目の行は、タイムゾーンが `Europe/Paris` で、略名は `CET`、UTC からのオフセットは `01:00:00` です。`f` は、夏時間が適用されないことを示しています。
```
pg_timezone_names
------------------
(Antarctica/South_Pole,NZDT,13:00:00,t)
(Europe/Paris,CET,01:00:00,f)
```
SQL ステートメントを実行してリスト全体を取得し、タイムゾーン名を検索します。約 600 行が返されます。返されるタイムゾーン名は大文字のイニシャルや頭字語 (例: GB、PRC、ROK) になっていますが、CONVERT\$1TIMEZONE 関数ではこれらはタイムゾーンの省略形ではなくタイムゾーン名として扱われます。
タイムゾーン名を使用してタイムゾーンを指定する場合、CONVERT\$1TIMEZONE は自動的に夏時間 (DST)、または '*timestamp*' によって指定される日付と時刻で有効なその他の現地の季節の慣習 (サマータイム、標準時、冬時間) を調整します。例えば、'Europe/London' は冬季は UTC を表し、夏季は 1 時間を追加します。Amazon Redshift は、[IANA タイムゾーンデータベース](https://www.iana.org/time-zones)をタイムゾーン仕様の信頼できるソースとして使用することに注意してください。
### タイムゾーンの略名の使用
タイムゾーン略名の完全なリストの最新版を表示するには、次のコマンドを実行します。
```
select pg_timezone_abbrevs();
```
結果には、タイムゾーンの略名、UTC オフセット、タイムゾーンが夏時間を採用しているかどうかのインジケーター (`t` または `f`) がカンマ区切りの文字列で含まれています。例えば、次のスニペットは、結果として 2 行が表示されます。最初の行には、太平洋夏時間の略名 `PDT` が含まれており、UTC からのオフセットは `-07:00:00` で、`t` は夏時間を採用していることを示しています。2 行目には、太平洋夏時間の略名 `PST` が含まれており、UTC からのオフセットは `-08:00:00` で、`f` は夏時間を採用していないことを示しています。
```
pg_timezone_abbrevs
--------------------
(PDT,-07:00:00,t)
(PST,-08:00:00,f)
```
この SQL ステートメントを実行してリスト全体を取得し、オフセットと夏時間のインジケーターに基づいて略名を検索します。約 200 行が返されます。
タイムゾーンの略名は、UTC からの固定オフセットを表します。タイムゾーンの略名を使用してタイムゾーンを指定する場合、CONVERT\$1TIMEZONE は UTC からの固定オフセットを使用し、現地の季節の慣習を調整しません。
### POSIX スタイル形式の使用
POSIX スタイルのタイムゾーン仕様は *STDoffset* または *STDoffsetDST* の形式であり、これらの *STD* はタイムゾーンの省略形、*offset* は UTC から西方向への時間単位の数値オフセット、および *DST* はオプションの夏時間ゾーンの省略形です。夏時間は、特定のオフセットより 1 時間早いことを想定しています。
POSIX スタイルのタイムゾーン形式では、グリニッジから西方向に正のオフセットが使用されます。これは、グリニッジから東方向に正のオフセットを使用する ISO-8601 規則とは対照的です。
POSIX スタイルのタイムゾーンの例を以下に示します。
+ PST8
+ PST8PDT
+ EST5
+ EST5EDT
**注記**
Amazon Redshift は、POSIX スタイルのタイムゾーン仕様を検証しないため、タイムゾーンを無効な値に設定する可能性があります。例えば、次のコマンドはタイムゾーンを無効な値に設定しますが、エラーを返しません。
```
set timezone to ‘xxx36’;
```
## 例
多くの例では、TICKIT サンプルデータセットを使用しています。詳細については、「[サンプルデータベース](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html)」を参照してください。
次の例は、タイムスタンプ値をデフォルトの UTC タイムゾーンから PST に変換します。
```
select convert_timezone('PST', '2008-08-21 07:23:54');
convert_timezone
------------------------
2008-08-20 23:23:54
```
次の例は、LISTTIME 列のタイムスタンプ値をデフォルトの UTC タイムゾーンから PST に変換します。タイムスタンプが夏時間の期間内であっても、変換後のタイムゾーンが略名 (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
```
次の例は、タイムスタンプの LISTTIME 列をデフォルトの UTC タイムゾーンから US/Pacific タイムゾーンに変換します。変換後のタイムゾーンはタイムゾーン名で指定されており、タイムスタンプは夏時間の期間内であるため、この関数は夏時間を返します。
```
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
```
次の例は、タイムスタンプの文字列を EST から PST に変換します。
```
select convert_timezone('EST', 'PST', '20080305 12:25:29');
convert_timezone
-------------------
2008-03-05 09:25:29
```
次の例は、変換後のタイムゾーンがタイムゾーン名 (America/New\$1York) で指定されており、タイムスタンプが標準時間の期間内にあるため、タイムスタンプを米国東部標準時に変換します。
```
select convert_timezone('America/New_York', '2013-02-01 08:00:00');
convert_timezone
---------------------
2013-02-01 03:00:00
(1 row)
```
次の例は、変換後のタイムゾーンがタイムゾーン名 (America/New\$1York) で指定されており、タイムスタンプが夏時間の期間内にあるため、タイムスタンプを米国東部夏時間に変換します。
```
select convert_timezone('America/New_York', '2013-06-01 08:00:00');
convert_timezone
---------------------
2013-06-01 04:00:00
(1 row)
```
次の例は、オフセットの使用を示しています。
```
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)
```
# CURRENT\$1DATE 関数
CURRENT\$1DATE は、現在のセッションのタイムゾーン (デフォルトは UTC) の日付をデフォルト形式 YYYY-MM-DD で返します。
**注記**
CURRENT\$1DATE は、現在のステートメントの開始日ではなく、現在のトランザクションの開始日を返します。複数のステートメントを含むトランザクションを 2008 年 10 月 1 日 23:59 に開始し、CURRENT\$1DATE を含むステートメントが 2008 年 10 月 2 日 00:00 に実行されるシナリオを考えてみましょう。CURRENT\$1DATE は `10/02/08` ではなく、`10/01/08` を返します。
## 構文
```
CURRENT_DATE
```
## 戻り型
DATE
## 例
次の例では、現在の日付を返します (関数が実行される AWS リージョン)。
```
select current_date;
date
------------
2008-10-01
```
次の例では、テーブルを作成し、列 `todays_date` のデフォルトが CURRENT\$1DATE である行を挿入し、テーブル内のすべての行を選択します。
```
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
```
# DATE\$1CMP 関数
DATE\$1CMP は 2 つの日付を比較します。この関数は、日付が同一の場合は `0`、*date1* が大きい場合は `1`、*date2* が大きい場合は `-1` を返します。
## 構文
```
DATE_CMP(date1, date2)
```
## 引数
*date1*
データ型 `DATE` の値または `DATE` 型と評価される式の列。
*date2*
データ型 `DATE` の値または `DATE` 型と評価される式の列。
## 戻り型
INTEGER
## 例
次のクエリは CALDATE 列の DATE 値を 2008 年 1 月 4 日の日付と比較し、CALDATE の値が 2008 年 1 月 4 日より前 (`-1`)、同じ (`0`)、より後 (`1`) であるかを返します。
```
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)
```
# DATE\$1CMP\$1TIMESTAMP 関数
DATE\$1CMP\$1TIMESTAMP は、日付とタイムスタンプを比較し、値が同一の場合は `0`、*date* が時間的により大きい場合は `1`、*timestamp* がより大きい場合は `-1` を返します。
## 構文
```
DATE_CMP_TIMESTAMP(date, timestamp)
```
## 引数
*date*
データ型 `DATE` の値または `DATE` 型と評価される式の列。
*timestamp*
データ型 `TIMESTAMP` の値または `TIMESTAMP` 型と評価される式の列。
## 戻り型
INTEGER
## 例
次の例は日付 `2008-06-18` と LISTTIME を比較します。LISTTIME 列の値はタイムスタンプです。この日付より前に作成されたリストは `1` を返し、この日付より後に作成されたリストは `-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)
```
# DATE\$1CMP\$1TIMESTAMPTZ 関数
DATE\$1CMP\$1TIMESTAMPTZ は、日付とタイムゾーン付きのタイムスタンプを比較し、値が同一の場合は `0`、*date* が時間的により大きい場合は `1`、*timestamptz* がより大きい場合は `-1` を返します。
## 構文
```
DATE_CMP_TIMESTAMPTZ(date, timestamptz)
```
## 引数
*date*
データ型 `DATE` の列または `DATE` 型に暗黙的に評価される式。
*timestamptz*
データ型 `TIMESTAMPTZ` の列または `TIMESTAMPTZ` 型に暗黙的に評価される式。
## 戻り型
INTEGER
## 例
次の例は日付 `2008-06-18` と LISTTIME を比較します。この日付より前に作成されたリストは `1` を返し、この日付より後に作成されたリストは `-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)
```
# DATEADD 関数
指定された間隔で DATE、TIME、TIMETZ、または TIMESTAMP の値を増分します。
## 構文
```
DATEADD( datepart, interval, {date|time|timetz|timestamp} )
```
## 引数
*datepart*
関数が実行される日付部分 (例: 年、月、日、または時間)。詳細については、「[日付関数またはタイムスタンプ関数の日付部分](r_Dateparts_for_datetime_functions.md)」を参照してください。
*interval*
ターゲット式に追加する間隔 ( 日数など ) を指定する整数。負の整数は間隔を減算します。
*date*\$1*time*\$1*timetz*\$1*timestamp*
DATE、TIME、TIMETZ、または TIMESTAMP の列、あるいは暗黙的に DATE、TIME、TIMETZ、または TIMESTAMP に変換される式。DATE、TIME、TIMETZ、または TIMESTAMP の式には、指定した日付部分が含まれている必要があります。
## 戻り型
入力データ型に応じて TIMESTAMP、TIME、または TIMETZ を指定します。
## DATE 列の例
次の例では、DATE テーブルに存在する 11 月の各日付に 30 日追加します。
```
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)
```
次の例は、リテラル日付値に 18 か月を追加します。
```
select dateadd(month,18,'2008-02-28');
date_add
---------------------
2009-08-28 00:00:00
(1 row)
```
DATEDIFF 関数のデフォルトの列名は DATE\$1ADD です。日付の値に使用するデフォルトのタイムスタンプは `00:00:00` です。
次の例では、タイムスタンプを指定しない日付の値に 30 分を追加します。
```
select dateadd(m,30,'2008-02-28');
date_add
---------------------
2008-02-28 00:30:00
(1 row)
```
完全名または略名で日付部分に名前を付けることができます。この場合、*m* は月ではなく分を表します。
## TIME 列の例
次のテーブルの TIME\$1TEST の例には、3 つの値が挿入された列 TIME\$1VAL (タイプ TIME) があります。
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
次の例では、TIME\$1TEST テーブルの各 TIME\$1VAL に 5 分を追加します。
```
select dateadd(minute,5,time_val) as minplus5 from time_test;
minplus5
---------------
20:05:00
00:05:00.5550
01:03:00
```
次の例では、リテラル時刻値に 8 時間を追加します。
```
select dateadd(hour, 8, time '13:24:55');
date_add
---------------
21:24:55
```
次の例では、時刻が 24:00:00 を超えるか 00:00:00 を下回る場合を示しています。
```
select dateadd(hour, 12, time '13:24:55');
date_add
---------------
01:24:55
```
## TIMETZ 列の例
これらの例の出力値は、デフォルトのタイムゾーンである UTC です。
次のテーブルの TIMETZ\$1TEST の例には、3 つの値が挿入された列 TIMETZ\$1VAL (タイプ TIMETZ) があります。
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
次の例では、TIMETZ\$1TEST テーブルの各 TIMETZ\$1VAL に 5 分を追加します。
```
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
```
次の例では、リテラルの timetz 値に 2 時間を追加します。
```
select dateadd(hour, 2, timetz '13:24:55 PST');
date_add
---------------
23:24:55+00
```
## TIMESTAMP 列の例
これらの例の出力値は、デフォルトのタイムゾーンである UTC です。
次のテーブルの TIMESTAMP\$1TEST の例には、3 つの値が挿入された列 TIMESTAMP\$1VAL (タイプ TIMESTAMP) があります。
```
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
```
次の例では、2000 年より前の TIMESTAMP\$1TEST の TIMESTAMP\$1VAL 値にのみ 20 年を加算しています。
```
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
```
次の例では、秒インジケータなしで書き込まれたリテラルタイムスタンプ値に 5 秒を加算します。
```
SELECT dateadd(second, 5, timestamp '2001-06-06');
date_add
---------------
2001-06-06 00:00:05
```
## 使用に関する注意事項
DATEADD(month, ...) および ADD\$1MONTHS 関数は、異なる月末になる日付を処理します。
+ ADD\$1MONTHS: 追加している日付が月の最終日である場合、結果は月の期間にかかわらず、常に結果の月の最終日になります。例えば、4 月 30 日 \$1 1 か月は 5 月 31 日になります。
```
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
(1 row)
```
+ DATEADD: 追加している日付が結果の月より短い場合、結果は月の最終日ではなく、結果の月の対応する日付になります。例えば、4 月 30 日 \$1 1 か月は 5 月 30 日になります。
```
select dateadd(month,1,'2008-04-30');
date_add
---------------------
2008-05-30 00:00:00
(1 row)
```
DATEADD 関数では dateadd(month, 12,…) または dateadd(year, 1, …) を使用するとき、うるう年の日付 02-29 は扱いが異なります。
```
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
```
# DATEDIFF 関数
DATEDIFF は 2 つの日付または時刻式の日付部分の差を返します。
## 構文
```
DATEDIFF( datepart, {date|time|timetz|timestamp}, {date|time|timetz|timestamp} )
```
## 引数
*datepart*
関数が実行される日付または時刻値 (年、月、または日、時、分、秒、ミリ秒、またはマイクロ秒) の特定部分。詳細については、「[日付関数またはタイムスタンプ関数の日付部分](r_Dateparts_for_datetime_functions.md)」を参照してください。
特に、DATEDIFF は 2 つの式の間で越える日付部分の境界の数を決定します。例えば、`12-31-2008` と `01-01-2009` の 2 つの日付間で年の差を計算しているとします。この場合、これらの日付は 1 日しか離れていないにもかかわらず、関数は 1 年を返します。2 つのタイムスタンプ (`01-01-2009 8:30:00` と `01-01-2009 10:00:00`) の間で時間の差が分かっている場合、結果は 2 時間になります。2 つのタイムスタンプ (`8:30:00` と `10:00:00`) の間で時間の差が分かっている場合、結果は 2 時間になります。
*date*\$1*time*\$1*timetz*\$1*timestamp*
DATE、TIME、TIMETZ、または TIMESTAMP の列、あるいは暗黙的に DATE、TIME、TIMETZ、または TIMESTAMP に変換される式。両方の式には、指定した日付部分または時刻部分を含める必要があります。2 番目の日付または時刻が 1 番目の日付または時刻よりも後である場合、結果は正です。2 番目の日付または時刻が 1 番目の日付または時刻よりも前である場合、結果は負です。
## 戻り型
BIGINT
## DATE 列の例
次の例では、2 つの日付リテラル値の間の差 (週単位) を取得します。
```
select datediff(week,'2009-01-01','2009-12-31') as numweeks;
numweeks
----------
52
(1 row)
```
次の例は、2 つの日付リテラル値の差 (時間単位) を検出します。日付の時刻値を指定しなかった場合、デフォルトで 00:00:00 に設定されます。
```
select datediff(hour, '2023-01-01', '2023-01-03 05:04:03');
date_diff
----------
53
(1 row)
```
次の例は、2 つの日付リテラル TIMESTAMETZ 値の差 (日単位) を検出します。
```
Select datediff(days, 'Jun 1,2008 09:59:59 EST', 'Jul 4,2008 09:59:59 EST')
date_diff
----------
33
```
次の例は、テーブルの同じ行の 2 つの日付の差 (日単位) を検出します。
```
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)
```
次の例では、過去のリテラル値と今日の日付の間の差 (四半期単位) を取得します。この例では、現在の日付を 2008 年 6 月 5 日とします。完全名または略名で日付部分に名前を付けることができます。DATEDIFF 関数のデフォルトの列名は DATE\$1DIFF です。
```
select datediff(qtr, '1998-07-01', current_date);
date_diff
-----------
40
(1 row)
```
次の例では、SALES テーブルと LISTING テーブルを結合し、リスト 1000 から 1005 に対してチケットをリストしてから何日後に販売されたかを計算します。これらのリストの販売を最長の待機期間は 15 日であり、最小は 1 日より短いです (0 日)。
```
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)
```
この例は、販売者が任意およびすべてのチケット販売を待機する平均時間を計算します。
```
select avg(datediff(hours, listtime, saletime)) as avgwait
from sales, listing
where sales.listid = listing.listid;
avgwait
---------
465
(1 row)
```
## TIME 列の例
次のテーブルの TIME\$1TEST の例には、3 つの値が挿入された列 TIME\$1VAL (タイプ TIME) があります。
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
次の例では、TIME\$1VAL 列と時刻リテラル間の時間数の差を検出します。
```
select datediff(hour, time_val, time '15:24:45') from time_test;
date_diff
-----------
-5
15
15
```
次の例では、2 つのリテラル時間値の分数の差を検出します。
```
select datediff(minute, time '20:00:00', time '21:00:00') as nummins;
nummins
----------
60
```
## TIMETZ 列の例
次のテーブルの TIMETZ\$1TEST の例には、3 つの値が挿入された列 TIMETZ\$1VAL (タイプ TIMETZ) があります。
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
次の例では、TIMETZ リテラルと timetz\$1val の間の時間数の差を検出します。
```
select datediff(hours, timetz '20:00:00 PST', timetz_val) as numhours from timetz_test;
numhours
----------
0
-4
1
```
次の例では、2 つのリテラル TIMETZ 値間の時間数の差を検出します。
```
select datediff(hours, timetz '20:00:00 PST', timetz '00:58:00 EST') as numhours;
numhours
----------
1
```
# DATE\$1PART 関数
DATE\$1PART は式から日付部分の値を抽出します。DATE\$1PART は PGDATE\$1PART 関数のシノニムです。
## 構文
```
DATE_PART(datepart, {date|timestamp})
```
## 引数
*datepart*
関数が実行される日付の値の特定部分 (例: 年、月、または日) の識別子リテラルまたは文字列。詳細については、「[日付関数またはタイムスタンプ関数の日付部分](r_Dateparts_for_datetime_functions.md)」を参照してください。
\$1*date*\$1*timestamp*\$1
日付列、タイムスタンプ列、または暗黙的に日付またはタイムスタンプに変換される式。*日付*または*タイムスタンプ*の列または式には、*datepart* で指定された日付部分が含まれている必要があります。
## 戻り型
DOUBLE
## 例
DATE\$1PART 関数のデフォルトの列名は `pgdate_part` です。
次の例の一部で使用されるデータの詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
次の例では、タイムスタンプリテラルから分を見つけます。
```
SELECT DATE_PART(minute, timestamp '20230104 04:05:06.789');
pgdate_part
-----------
5
```
次の例では、タイムスタンプリテラルから週番号を見つけます。週番号の計算は、ISO 8601 標準に従います。詳細については、Wikipedia の「[ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)」を参照してください。
```
SELECT DATE_PART(week, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
18
```
次の例では、タイムスタンプリテラルから日付を見つけます。
```
SELECT DATE_PART(day, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
2
```
次の例では、タイムスタンプリテラルから曜日を見つけます。曜日番号の計算は、日曜日から始まる 0～6 の整数です。
```
SELECT DATE_PART(dayofweek, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
1
```
次の例では、タイムスタンプリテラルから世紀を見つけます。世紀の計算は、ISO 8601 標準に従います。詳細については、Wikipedia の「[ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)」を参照してください。
```
SELECT DATE_PART(century, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
21
```
次の例は、タイムスタンプリテラルからミレニアムを検出します。ミレニアムの計算は、ISO 8601 標準に従います。詳細については、Wikipedia の「[ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)」を参照してください。
```
SELECT DATE_PART(millennium, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
3
```
次の例は、タイムスタンプリテラルからマイクロ秒を検出します。マイクロ秒の計算は、ISO 8601 標準に従います。詳細については、Wikipedia の「[ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)」を参照してください。
```
SELECT DATE_PART(microsecond, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
789000
```
次の例では、日付リテラルから月を見つけます。
```
SELECT DATE_PART(month, date '20220502');
pgdate_part
-----------
5
```
次の例は、DATE\$1PART 関数をテーブルの列に適用します。
```
SELECT date_part(w, listtime) AS weeks, listtime
FROM listing
WHERE listid=10
weeks | listtime
------+---------------------
25 | 2008-06-17 09:44:54
(1 row)
```
完全形あるいは省略形の日付部分に名前を付けることができます。この場合、*w* は週を指します。
曜日の日付部分は、0～6 の整数を返します (0 は日曜日)。dow (曜日) とともに DATE\$1PART を使用し、土曜のイベントを表示します。
```
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)
```
# DATE\$1PART\$1YEAR 関数
DATE\$1PART\$1YEAR 関数は日付から年を抽出します。
## 構文
```
DATE_PART_YEAR(date)
```
## 引数
*date*
データ型 `DATE` の列または `DATE` 型に暗黙的に評価される式。
## 戻り型
INTEGER
## 例
次の例では、日付リテラルから年を見つけます。
```
SELECT DATE_PART_YEAR(date '20220502 04:05:06.789');
date_part_year
---------------
2022
```
次の例は CALDATE 列から年を抽出します。CALDATE 列の値は日付です。この例で使用されているデータの詳細については、「[サンプルデータベース](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)
```
# DATE\$1TRUNC 関数
DATE\$1TRUNC 関数は、指定した日付部分 (時、日、月など) に基づいてタイムスタンプの式またはリテラルを切り捨てます。
## 構文
```
DATE_TRUNC('datepart', timestamp)
```
## 引数
*datepart*
タイムスタンプの値を切り捨てる日付部分。入力*タイムスタンプ*は、入力 *datepart* の精度で切り捨てられます。例えば、`month` は、その月の初日で切り捨てられます。有効な形式は次のとおりです。
+ microsecond、microseconds
+ millisecond、milliseconds
+ second、seconds
+ minute、minutes
+ hour、hours
+ day、days
+ week、weeks
+ month、months
+ quarter、quarters
+ year、years
+ decade、decades
+ century、centuries
+ millennium、millennia
形式の略語の詳細については、「[日付関数またはタイムスタンプ関数の日付部分](r_Dateparts_for_datetime_functions.md)」を参照してください。
*timestamp*
タイムスタンプの列、あるいは暗黙的にタイムスタンプに変換される式。
## 戻り型
TIMESTAMP
## 例
入力タイムスタンプを秒単位で切り捨てます。
```
SELECT DATE_TRUNC('second', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:06
```
入力タイムスタンプを分単位で切り捨てます。
```
SELECT DATE_TRUNC('minute', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:00
```
入力タイムスタンプを時間単位で切り捨てます。
```
SELECT DATE_TRUNC('hour', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:00:00
```
入力タイムスタンプを日単位で切り捨てます。
```
SELECT DATE_TRUNC('day', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 00:00:00
```
入力タイムスタンプを月の初日で切り捨てます。
```
SELECT DATE_TRUNC('month', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
入力タイムスタンプを四半期の初日で切り捨てます。
```
SELECT DATE_TRUNC('quarter', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
入力タイムスタンプを 1 年の初日で切り捨てます。
```
SELECT DATE_TRUNC('year', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-01-01 00:00:00
```
入力タイムスタンプを 1 世紀の初日で切り捨てます。
```
SELECT DATE_TRUNC('millennium', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2001-01-01 00:00:00
```
入力タイムスタンプを月曜日に切り捨てます。
```
select date_trunc('week', TIMESTAMP '20220430 04:05:06.789');
date_trunc
2022-04-25 00:00:00
```
次の例では、DATE\$1TRUNC 関数が 'week' の日付部分を使用して、各週の月曜日の日付を返します。
```
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
```
# EXTRACT 関数
EXTRACT 関数は、TIMESTAMP、TIMESTAMPTZ、TIME、TIMETZ、 INTERVAL YEAR TO MONTH、または INTERVAL DAY TO SECOND の値から日付または時刻のパートを返します。例としては、タイムスタンプの日、月、年、時、分、秒、ミリ秒、マイクロ秒などがあります。
## 構文
```
EXTRACT(datepart FROM source)
```
## 引数
*datepart*
日、月、年、時、分、秒、ミリ秒、マイクロ秒など、抽出する日付または時刻のサブフィールド。有効な値については、「[日付関数またはタイムスタンプ関数の日付部分](r_Dateparts_for_datetime_functions.md)」を参照してください。
* ソース*
評価結果が TIMESTAMP、TIMESTAMPTZ、TIME、TIMETZ、INTERVAL YEAR TO MONTH、または INTERVAL DAY TO SECOND のデータ型になる列または式。
## 戻り型
source 値が TIMESTAMP、TIME、TIMETZ、INTERVAL YEAR TO MONTH、または INTERVAL DAY TO SECOND のデータ型として評価される場合は INTEGER。**
*source* 値がデータ型 TIMESTAMPTZ として評価される場合は、DOUBLE PRECISION。
## TIMESTAMP の例
次の例では、支払価格が 10,000 USD 以上であった販売の週の数を判定します。この例では、TICKIT データを使用します。詳細については、「[サンプルデータベース](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
```
次の例では、リテラルタイムスタンプの値から分の値を返します。
```
select extract(minute from timestamp '2009-09-09 12:08:43');
date_part
-----------
8
```
次の例は、リテラルタイムスタンプ値からミリ秒の値を返します。
```
select extract(ms from timestamp '2009-09-09 12:08:43.101');
date_part
-----------
101
```
## TIMESTAMPTZ の例
次の例は、リテラル timestamptz 値から年の値を返します。
```
select extract(year from timestamptz '1.12.1997 07:37:16.00 PST');
date_part
-----------
1997
```
## TIME の例
次のテーブルの TIME\$1TEST の例には、3 つの値が挿入された列 TIME\$1VAL (タイプ TIME) があります。
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
次の例は、各 time\$1val から分を抽出します。
```
select extract(minute from time_val) as minutes from time_test;
minutes
-----------
0
0
58
```
次の例は、各 time\$1val から時間を抽出します。
```
select extract(hour from time_val) as hours from time_test;
hours
-----------
20
0
0
```
次の例では、リテラル値からミリ秒を抽出します。
```
select extract(ms from time '18:25:33.123456');
date_part
-----------
123
```
## TIMETZ の例
次のテーブルの TIMETZ\$1TEST の例には、3 つの値が挿入された列 TIMETZ\$1VAL (タイプ TIMETZ) があります。
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
次の例では、各 timetz\$1val から時間を抽出します。
```
select extract(hour from timetz_val) as hours from time_test;
hours
-----------
4
0
5
```
次の例では、リテラル値からミリ秒を抽出します。抽出が処理される前には、リテラルは UTC に変換されません。
```
select extract(ms from timetz '18:25:33.123456 EST');
date_part
-----------
123
```
次の例は、リテラル timetz 値から、UTC からのタイムゾーンオフセット時を返します。
```
select extract(timezone_hour from timetz '1.12.1997 07:37:16.00 PDT');
date_part
-----------
-7
```
## INTERVAL YEAR TO MONTH と INTERVAL DAY TO SECOND の例
次の例では、36 時間 (1 日と 12 時間) を定義する INTERVAL DAY TO SECOND から日のパートである `1` を抽出します。
```
select EXTRACT('days' from INTERVAL '36 hours' DAY TO SECOND)
date_part
------------------
1
```
次の例では、15 か月 (1 年と 3 か月) を定義する YEAR TO MONTH から月のパートである `3` を抽出します。
```
select EXTRACT('month' from INTERVAL '15 months' YEAR TO MONTH)
date_part
------------------
3
```
次の例では、30 か月 (2 年と 6 か月) から月のパートである `6` を抽出します。
```
select EXTRACT('month' from INTERVAL '30' MONTH)
date_part
------------------
6
```
次の例では、50 時間 (2 日と 2 時間) から時間のパートである `2` を抽出します。
```
select EXTRACT('hours' from INTERVAL '50' HOUR)
date_part
------------------
2
```
次の例では、1 時間 11 分 11.123 秒から分のパートである `11` を抽出します。
```
select EXTRACT('minute' from INTERVAL '70 minutes 70.123 seconds' MINUTE TO SECOND)
date_part
------------------
11
```
次の例では、1 日 1 時間 1 分 1.11 秒から秒のパートである `1.11` を抽出します。
```
select EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND)
date_part
------------------
1.11
```
次の例では、INTERVAL の合計時間数を抽出します。各パートが抽出され、合計に追加されます。
```
select EXTRACT('days' from INTERVAL '50' HOUR) * 24 + EXTRACT('hours' from INTERVAL '50' HOUR)
?column?
------------------
50
```
次の例では、INTERVAL の合計秒数を抽出します。各パートが抽出され、合計に追加されます。
```
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
```
# GETDATE 関数
GETDATE は、現在のセッションのタイムゾーン (デフォルトでは UTC) で現在の日付と時刻を返します。トランザクションブロック内にある場合でも、現在のステートメントの開始日または開始時刻を返します。
## 構文
```
GETDATE()
```
かっこが必要です。
## 戻り型
TIMESTAMP
## 例
次の例は、GETDATE 関数を使用して現在の日付の完全なタイムスタンプを返します。
```
select getdate();
timestamp
---------------------
2008-12-04 16:10:43
```
次の例では、TRUNC 関数内の GETDATE 関数を使用し、時刻のない現在の日付を返します。
```
select trunc(getdate());
trunc
------------
2008-12-04
```
# INTERVAL\$1CMP 関数
INTERVAL\$1CMP は 2 つの間隔を比較し、1 番目の間隔が大きい場合は `1`、2 番目の間隔が大きい場合は `-1`、間隔が等しい場合は `0` をそれぞれ返します。詳細については、「[修飾子構文を使用しない間隔リテラルの例](r_interval_literals.md)」を参照してください。
## 構文
```
INTERVAL_CMP(interval1, interval2)
```
## 引数
*interval1*
間隔のリテラル値。
*interval2*
間隔のリテラル値。
## 戻り型
INTEGER
## 例
次の例は `3 days` の値と `1 year` を比較しています。
```
select interval_cmp('3 days','1 year');
interval_cmp
--------------
-1
```
この例では値 `7 days` と `1 week` を比較しています。
```
select interval_cmp('7 days','1 week');
interval_cmp
--------------
0
```
次の例は `1 year` の値と `3 days` を比較しています。
```
select interval_cmp('1 year','3 days');
interval_cmp
--------------
1
```
# LAST\$1DAY 関数
LAST\$1DAY は、*date* を含む月の最終日の日付を返します。戻り値の型は、*date* 引数のデータ型にかかわらず常に DATE です。
特定の日付部分の取得の詳細については、「[DATE\$1TRUNC 関数](r_DATE_TRUNC.md)」を参照してください。
## 構文
```
LAST_DAY( { date | timestamp } )
```
## 引数
*date* \$1 *timestamp*
データ型 `DATE` または `TIMESTAMP` の列、あるいは `DATE` 型または `TIMESTAMP` 型に暗黙的に評価される式。
## 戻り型
DATE
## 例
次の例では、現在の月の最終日の日付が返されます。
```
select last_day(sysdate);
last_day
------------
2014-01-31
```
次の例では、月の最後の 7 日間それぞれに販売されたチケット数が返されます。SALETIME 列の値はタイムスタンプです。
```
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)
```
# MONTHS\$1BETWEEN 関数
MONTHS\$1BETWEEN は、2 つの日付の間の月数を算出します。
1 番目の日付が 2 番目の日付より値の場合、結果は正になります。それ以外の場合、結果は負になります。
どちらかの引数が null の場合、結果は NULL になります。
## 構文
```
MONTHS_BETWEEN( date1, date2 )
```
## 引数
*date1*
データ型 `DATE` の列または `DATE` 型に暗黙的に評価される式。
*date2*
データ型 `DATE` の列または `DATE` 型に暗黙的に評価される式。
## 戻り型
FLOAT8
結果の整数部分は、日付の年の値と月の値の差分に基づいて決まります。結果の小数部分は、日付の曜日およびタイムスタンプの値から計算され、1 か月が 31 日であると想定しています。
*date1* と *date2* のどちらにも月の同じ日付が含まれているか (1/15/14 と 2/15/14 など)、月の末日が含まれている場合 (8/31/14 と 9/30/14 など)、タイムスタンプ部分 (存在する場合) が一致するかどうかに関係なく、結果は日付の年と月の値に基づく整数となります。
## 例
次の例では、1969 年 1 月 18 日から 1969 年 3 月 18 日までの月数を返します。
```
select months_between('1969-01-18', '1969-03-18')
as months;
months
----------
-2
```
次の例では、1969 年 1 月 18 日から 1969 年 1 月 18 日までの月数を返します。
```
select months_between('1969-01-18', '1969-01-18')
as months;
months
----------
0
```
次の例では、イベントの最初の開催から最後の開催までの月数を返します。
```
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
```
# NEXT\$1DAY 関数
NEXT\$1DAY は、指定の日付より後に指定の曜日となる最初の日付を返します。
*day* 値が指定の日付と同じ曜日の場合、その曜日の次の出現が返されます。
## 構文
```
NEXT_DAY( { date | timestamp }, day )
```
## 引数
*date* \$1 *timestamp*
データ型 `DATE` または `TIMESTAMP` の列、あるいは `DATE` 型または `TIMESTAMP` 型に暗黙的に評価される式。
*日*
任意の曜日の名前を含む文字列。大文字化は関係ありません。
有効な値は次のとおりです。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_NEXT_DAY.html)
## 戻り型
DATE
## 例
次の例では、2014 年 8 月 20 日後の最初の火曜日を返します。
```
select next_day('2014-08-20','Tuesday');
next_day
-----------
2014-08-26
```
次の例では、2008 年 1 月 1 日以降の第 1 火曜日の日付を 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
```
次の例は、第 3 四半期のターゲットマーケティング日を取得します。
```
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
```
# SYSDATE 関数
SYSDATE は、現在のセッションのタイムゾーン (デフォルトでは UTC) で現在の日付と時刻を返します。
**注記**
SYSDATE は現在のステートメントではなく、現在のトランザクションの開始日と時刻を返します。
## 構文
```
SYSDATE
```
この関数に引数は必要ありません。
## 戻り型
TIMESTAMP
## 例
次の例は、SYSDATE 関数を使用して現在の日付の完全なタイムスタンプを返します。
```
select sysdate;
timestamp
----------------------------
2008-12-04 16:10:43.976353
```
次の例は TRUNC 関数内で SYSDATE 関数を使用し、時刻のない現在の日付を返します。
```
select trunc(sysdate);
trunc
------------
2008-12-04
```
次のクエリは、クエリが発行された日付からその 120 日前までの間の日付の販売情報を返します。
```
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
...
```
# TIMEOFDAY 関数
TIMEOFDAY は文字列値として曜日、日付、および時刻を返すために使用される特別なエイリアスです。トランザクションブロック内にある場合でも、現在のステートメントの日付文字列の時刻を返します。
## 構文
```
TIMEOFDAY()
```
## 戻り型
VARCHAR
## 例
次の例では、TIMEOFDAY 関数を使用して、現在の日付と時刻を返します。
```
select timeofday();
timeofday
------------
Thu Sep 19 22:53:50.333525 2013 UTC
```
# TIMESTAMP\$1CMP 関数
2 つのタイムスタンプの値を比較し、整数を返します。タイムスタンプが同じである場合、関数は `0` を返します。最初のタイムスタンプがより大きい場合、関数は `1` を返します。2 番目のタイムスタンプがより大きい場合、関数は `-1` を返します。
## 構文
```
TIMESTAMP_CMP(timestamp1, timestamp2)
```
## 引数
*timestamp1*
データ型 `TIMESTAMP` の列または `TIMESTAMP` 型に暗黙的に評価される式。
*timestamp2*
データ型 `TIMESTAMP` の列または `TIMESTAMP` 型に暗黙的に評価される式。
## 戻り型
INTEGER
## 例
次の例では、タイムスタンプ間を比較し、比較の結果を示します。
```
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
```
次の例では、出品の LISTTIME と SALETIME を比較します。販売のタイムスタンプは出品のタイムスタンプより後であるため、すべての出品で TIMESTAMP\$1CMP の値は `-1` です。
```
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)
```
この例は、両方のタイムスタンプが同一の場合に TIMESTAMP\$1CMP が 0 を返すことを示しています。
```
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)
```
# TIMESTAMP\$1CMP\$1DATE 関数
TIMESTAMP\$1CMP\$1DATE は、タイムスタンプの値と日付を比較します。タイムスタンプと日付の値が同じである場合、関数は `0` を返します。タイムスタンプが時間的により大きい場合、関数は `1` を返します。日付がより大きい場合、関数は `-1` を返します。
## 構文
```
TIMESTAMP_CMP_DATE(timestamp, date)
```
## 引数
*timestamp*
データ型 `TIMESTAMP` の列または `TIMESTAMP` 型に暗黙的に評価される式。
*date*
データ型 `DATE` の列または `DATE` 型に暗黙的に評価される式。
## 戻り型
INTEGER
## 例
次の例は LISTTIME と日付 `2008-06-18` を比較します。この日付より後に作成されたリストは `1` を返し、この日付より前に作成されたリストは `-1` を返します。LISTTIME の値はタイムスタンプです。
```
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)
```
# TIMESTAMP\$1CMP\$1TIMESTAMPTZ 関数
TIMESTAMP\$1CMP\$1TIMESTAMPTZ は、タイムスタンプ式の値と、タイムゾーン式を含むタイムスタンプを比較します。タイムスタンプと、タイムゾーン付きのタイムスタンプの値が同じである場合、関数は `0` を返します。タイムスタンプが時間的により大きい場合、関数は `1` を返します。タイムゾーン付きのタイムスタンプがより大きい場合、関数は `–1` を返します。
## 構文
```
TIMESTAMP_CMP_TIMESTAMPTZ(timestamp, timestamptz)
```
## 引数
*timestamp*
データ型 `TIMESTAMP` の値または `TIMESTAMP` 型に暗黙的に評価される式。
*timestamptz*
データ型 `TIMESTAMPTZ` の列または `TIMESTAMPTZ` 型に暗黙的に評価される式。
## 戻り型
INTEGER
## 例
次の例では、タイムスタンプと、タイムゾーン付のタイムスタンプを比較し、比較の結果を示します。
```
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
```
# TIMESTAMPTZ\$1CMP 関数
TIMESTAMPTZ\$1CMP は、タイムゾーン値を含む 2 つのタイムスタンプの値を比較し、整数を返します。タイムスタンプが同じである場合、関数は `0` を返します。最初のタイムスタンプが時間的により大きい場合、関数は `1` を返します。2 番目のタイムスタンプがより大きい場合、関数は `–1` を返します。
## 構文
```
TIMESTAMPTZ_CMP(timestamptz1, timestamptz2)
```
## 引数
*timestamptz1*
データ型 `TIMESTAMPTZ` の列または `TIMESTAMPTZ` 型に暗黙的に評価される式。
*timestamptz2*
データ型 `TIMESTAMPTZ` の列または `TIMESTAMPTZ` 型に暗黙的に評価される式。
## 戻り型
INTEGER
## 例
次の例では、タイムゾーン付きのタイムスタンプ間を比較し、比較の結果を示します。
```
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
```
# TIMESTAMPTZ\$1CMP\$1DATE 関数
TIMESTAMPTZ\$1CMP\$1DATE は、タイムスタンプの値と日付を比較します。タイムスタンプと日付の値が同じである場合、関数は `0` を返します。タイムスタンプが時間的により大きい場合、関数は `1` を返します。日付がより大きい場合、関数は `–1` を返します。
## 構文
```
TIMESTAMPTZ_CMP_DATE(timestamptz, date)
```
## 引数
*timestamptz*
データ型 `TIMESTAMPTZ` の列または `TIMESTAMPTZ` 型に暗黙的に評価される式。
*date*
データ型 `DATE` の列または `DATE` 型に暗黙的に評価される式。
## 戻り型
INTEGER
## 例
次の例では、LISTTIME (タイムゾーン付きのタイムスタンプ) と日付 `2008-06-18` を比較します。この日付より後に作成されたリストは `1` を返し、この日付より前に作成されたリストは `-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)
```
# TIMESTAMPTZ\$1CMP\$1TIMESTAMP 関数
TIMESTAMPTZ\$1CMP\$1TIMESTAMP は、タイムゾーン式を含むタイムスタンプの値とタイムスタンプ式を比較します。タイムゾーン付きのタイムスタンプと、タイムスタンプ値が同じである場合、関数は `0` を返します。タイムゾーン付きのタイムスタンプが時間的に大きい場合、関数は `1` を返します。タイムスタンプがより大きい場合、関数は `–1` を返します。
## 構文
```
TIMESTAMPTZ_CMP_TIMESTAMP(timestamptz, timestamp)
```
## 引数
*timestamptz*
データ型 `TIMESTAMPTZ` の列または `TIMESTAMPTZ` 型に暗黙的に評価される式。
*timestamp*
データ型 `TIMESTAMP` の列または `TIMESTAMP` 型に暗黙的に評価される式。
## 戻り型
INTEGER
## 例
次の例では、タイムゾーン付きタイムスタンプとタイムスタンプを比較し、比較の結果を示しています。
```
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
```
# TIMEZONE 関数
TIMEZONE は、指定されたタイムゾーンのタイムスタンプとタイムスタンプ値を返します。
タイムゾーンの設定方法の詳細と例については、「[timezone](r_timezone_config.md)」を参照してください。
タイムゾーンの変換方法の詳細と例については、「[CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md)」を参照してください。
## 構文
```
TIMEZONE('timezone', { timestamp | timestamptz })
```
## 引数
*timezone*
戻り値のタイムゾーン。タイムゾーンは、タイムゾーン名 (**'Africa/Kampala'** または **'Singapore'** など) またはタイムゾーンの略名 (**'UTC'** または **'PDT'** など) として指定できます。サポートされるタイムゾーン名のリストを表示するには、次のコマンドを実行します。
```
select pg_timezone_names();
```
サポートされるタイムゾーン省略形のリストを表示するには、次のコマンドを実行します。
```
select pg_timezone_abbrevs();
```
Amazon Redshift は、[IANA タイムゾーンデータベース](https://www.iana.org/time-zones)をタイムゾーン仕様の信頼できるソースとして使用することに注意してください。詳細な説明と例については、[タイムゾーンの使用上の注意](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes) を参照してください。
*timestamp* \$1 *timestamptz*
TIMESTAMP 型または TIMESTAMPTZ 型となる式、あるいは暗黙的にタイムスタンプまたはタイムゾーン付きのタイムスタンプに強制変換できる値。
## 戻り型
TIMESTAMP 式で使用する場合は TIMESTAMPTZ。
TIMESTAMPTZ 式で使用する場合は TIMESTAMP。
## 例
次の場合は、PST タイムゾーンからタイムスタンプ `2008-06-17 09:44:54` を使用して UTC タイムゾーンのタイムスタンプを返します。
```
SELECT TIMEZONE('PST', '2008-06-17 09:44:54');
timezone
-----------------------
2008-06-17 17:44:54+00
```
次の場合は、UTC タイムゾーン `2008-06-17 09:44:54+00` を含むタイムスタンプを使用して PST タイムゾーンのタイムスタンプを返します。
```
SELECT TIMEZONE('PST', timestamptz('2008-06-17 09:44:54+00'));
timezone
-----------------------
2008-06-17 01:44:54
```
# TO\$1TIMESTAMP 関数
TO\$1TIMESTAMP は TIMESTAMP 文字列を TIMESTAMPTZ に返します。Amazon Redshift のその他の日付および時刻関数のリストについては、「[日付および時刻関数](Date_functions_header.md)」を参照してください。
## 構文
```
to_timestamp(timestamp, format)
```
```
to_timestamp (timestamp, format, is_strict)
```
## 引数
*timestamp*
*format* により指定された形式でタイムスタンプ値を表す文字列。この引数を空のままにすると、タイムスタンプ値はデフォルトで `0001-01-01 00:00:00` に設定されます。
*format*
*timestamp* 値の形式を定義する文字列リテラル。タイムゾーン (**TZ**、**tz**、または **OF**) を含む形式は、入力としてサポートされていません。有効なタイムスタンプ形式については、「[日時形式の文字列](r_FORMAT_strings.md)」を参照してください。
*is\$1strict*
入力タイムスタンプ値が範囲外である場合にエラーを返すかどうかを指定するオプションのブール値。*is\$1strict* が TRUE に設定されている場合、範囲外の値があるとエラーが返されます。*is\$1strict* がデフォルトの FALSE に設定されている場合、オーバーフロー値が受け入れられます。
## 戻り型
TIMESTAMPTZ
## 例
次の例は、TO\$1TIMESTAMP 関数を使用して TIMESTAMP 文字列を 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
```
日付の TO\$1TIMESTAMP 部分を渡すこともできます。残りの日付部分はデフォルト値に設定されます。時刻は出力に含まれません。
```
SELECT TO_TIMESTAMP('2017','YYYY');
to_timestamp
--------------------------
2017-01-01 00:00:00+00
```
次の SQL ステートメントは、文字列「2011-12-18 24:38:15」を TIMESTAMPTZ に変換します。その結果、時間数が 24 時間を超えるため、翌日に該当する TIMESTAMPTZ になります。
```
SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS');
to_timestamp
----------------------
2011-12-19 00:38:15+00
```
次の SQL ステートメントは、文字列「2011-12-18 24:38:15」を TIMESTAMPTZ に変換します。タイムスタンプの時刻値が 24 時間を超えているため、結果はエラーになります。
```
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
```
# TRUNC 関数
`TIMESTAMP` を切り捨て、`DATE` を返します。
この関数は数値を切り捨てることもできます。詳細については、「[TRUNC 関数](r_TRUNC.md)」を参照してください。
## 構文
```
TRUNC(timestamp)
```
## 引数
*timestamp*
データ型 `TIMESTAMP` の列または `TIMESTAMP` 型に暗黙的に評価される式。
`00:00:00` を時刻とするタイムスタンプ値を返すには、関数の結果を `TIMESTAMP` にキャストします。
## 戻り型
DATE
## 例
次の例では、SYSDATE 関数 (タイムスタンプを返す) の結果から日付部分を返します。
```
SELECT SYSDATE;
+----------------------------+
| timestamp |
+----------------------------+
| 2011-07-21 10:32:38.248109 |
+----------------------------+
SELECT TRUNC(SYSDATE);
+------------+
| trunc |
+------------+
| 2011-07-21 |
+------------+
```
次の例では、TRUNC 関数を `TIMESTAMP` 列に適用します。戻り型は日付です。
```
SELECT TRUNC(starttime) FROM event
ORDER BY eventid LIMIT 1;
+------------+
| trunc |
+------------+
| 2008-01-25 |
+------------+
```
次の例は、TRUNC 関数の結果を `TIMESTAMP` にキャストして、`00:00:00` を時刻とするタイムスタンプ値を返します。
```
SELECT CAST((TRUNC(SYSDATE)) AS TIMESTAMP);
+---------------------+
| trunc |
+---------------------+
| 2011-07-21 00:00:00 |
+---------------------+
```
# 日付関数またはタイムスタンプ関数の日付部分
次のテーブルは、次の関数に対する引数として受け取る、日付部分および時刻部分の名前と略名を指定します。
+ DATEADD
+ DATEDIFF
+ DATE\$1PART
+ EXTRACT
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_Dateparts_for_datetime_functions.html)
## 結果のバリエーション (秒、ミリ秒、マイクロ秒）
異なる日付関数が秒、ミリ秒、またはマイクロ秒を日付部分として指定する場合、クエリ結果にわずかな違いが生じます。
+ EXTRACT 関数は、上位および下位の日付部分は無視し、指定された日付部分のみの整数を返します。指定された日付部分が秒の場合、ミリ秒およびマイクロ秒は結果に含まれません。指定された日付部分がミリ秒の場合、秒およびマイクロ秒は結果に含まれません。指定された日付部分がマイクロ秒の場合、秒およびミリ秒は結果に含まれません。
+ DATE\$1PART 関数は、指定された日付部分にかかわらず、タイムスタンプの完全な秒部分を返します。必要に応じて小数値または整数を返します。
例えば、次のクエリの結果を比較します。
```
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
```
## CENTURY、EPOCH、DECADE、および MIL ノート
CENTURY または CENTURIES
Amazon Redshift は CENTURY を *\$1\$1\$11* の年に始まり `###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
Amazon Redshift の EPOCH の実装は、クラスターのあるタイムゾーンから独立した 1970-01-01 00:00:00.000000 に関連します。クラスターが設置されているタイムゾーンによって、時差による結果を補正する必要がある場合があります。
次の内容の例を以下に示します。
1. EVENT テーブルに基づいて EVENT\$1EXAMPLE というテーブルを作成します。この CREATE AS コマンドは、DATE\$1PART 関数を使用してデータ列 (デフォルトでは PGDATE\$1PART と名づけられる) を作成し、各イベントのエポック値を保存します。
1. PG\$1TABLE\$1DEF から EVENT\$1EXAMPLE の列とデータタイプを選択します。
1. EVENT\$1EXAMPLE テーブルから EVENTNAME、STARTTIME と PGDATE\$1PART を選択して、日付と時間の複数の形式を表示します。
1. EVENTNAME と STARTTIME をそれぞれ選択します。1 秒間隔のタイムゾーンを指定しないタイムスタンプを使って PGDATE\$1PART のエポック値を変換し、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
...
```
DECADE または DECADES
Amazon Redshift は共通カレンダーに基づいて DECADE または DECADES DATEPART を解釈します。例えば、共通カレンダーが年 1 から始まるため、最初の 10 年 (decade 1) は 0001-01-01 から 0009-12-31 であり、2 番目の 10 年 (decade 2) は 0010-01-01 から 0019-12-31 です。例えば、decade 201 は 2000-01-01 から 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 または MILS
Amazon Redshift は MIL を *\$1001* の年の初めの日に始まり `#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
```