日付と時刻を扱う関数

このセクションのほとんどの関数では、Europe/Amsterdam のような省略可能な time zone 引数を指定できます。この場合、time zone にはローカル (デフォルト) ではなく、指定したものが使用されます。

例

SELECT
    toDateTime('2016-06-15 23:00:00') AS time,
    toDate(time) AS date_local,
    toDate(time, 'Asia/Yekaterinburg') AS date_yekat,
    toString(time, 'US/Samoa') AS time_samoa

┌────────────────time─┬─date_local─┬─date_yekat─┬─time_samoa──────────┐
│ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-16 │ 2016-06-15 09:00:00 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘

UTCTimestamp

導入バージョン: v22.11.0

解析時点の現在の日時を返します。この関数は定数式です。

この関数は、now('UTC') と同じ結果を返します。追加されたのは MySQL サポートのためだけです。推奨される使用方法は now です。

構文

UTCTimestamp()

別名: UTC_timestamp

引数

なし。

戻り値

解析時点における現在の日付と時刻を返します。DateTime

例

現在の UTC タイムスタンプを取得

SELECT UTCTimestamp()

┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘

YYYYMMDDToDate

導入バージョン: v23.9.0

年、月、日を含む数値を Date に変換します。この関数は、toYYYYMMDD() 関数の逆です。入力が有効な Date 値を表していない場合、出力は未定義です。

構文

YYYYMMDDToDate(YYYYMMDD)

引数

YYYYMMDD — 年、月、日を含む数値。(U)Int* または Float* または Decimal

戻り値

指定された引数から Date 型の値を返します Date

例

SELECT YYYYMMDDToDate(20230911);

┌─YYYYMMDDToDate(20230911)─┐
│               2023-09-11 │
└──────────────────────────┘

YYYYMMDDToDate32

導入バージョン: v23.9.0

年、月、日を表す数値を Date32 に変換します。この関数は、toYYYYMMDD() 関数の逆です。入力が有効な Date32 値を表していない場合、出力は未定義です。

構文

YYYYMMDDToDate32(YYYYMMDD)

引数

YYYYMMDD — 年・月・日を表す数値。(U)Int* または Float* または Decimal

戻り値

指定された引数から Date32 型の値を返します Date32

例

SELECT YYYYMMDDToDate32(20000507);

┌─YYYYMMDDToDate32(20000507)─┐
│                 2000-05-07 │
└────────────────────────────┘

YYYYMMDDhhmmssToDateTime

導入バージョン: v23.9.0

年、月、日、時、分、秒を含む数値を DateTime に変換します。この関数は、toYYYYMMDDhhmmss() 関数の逆です。入力が有効な DateTime 値を表していない場合、出力は未定義です。

構文

YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])

引数

YYYYMMDDhhmmss — 年、月、日、時、分、秒を含む数値。(U)Int* または Float* または Decimal
timezone — タイムゾーン名。String

戻り値

指定した引数から DateTime 値を返します。DateTime

例

SELECT YYYYMMDDhhmmssToDateTime(20230911131415);

┌─YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│                      2023-09-11 13:14:15 │
└──────────────────────────────────────────┘

YYYYMMDDhhmmssToDateTime64

導入バージョン: v23.9.0

年、月、日、時、分、秒を表す数値を DateTime64 に変換します。この関数は toYYYYMMDDhhmmss() 関数の逆です。入力が有効な DateTime64 値を表していない場合、出力は未定義です。

構文

YYYYMMDDhhmmssToDateTime64(YYYYMMDDhhmmss[, precision[, timezone]])

引数

YYYYMMDDhhmmss — 年、月、日、時、分、秒を含む数値。(U)Int* または Float* または Decimal
precision — 小数部の精度 (0～9) 。UInt8
timezone — タイムゾーン名。String

戻り値

指定された引数から DateTime64 型の値を返します。DateTime64

例

SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');

┌─YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul')─┐
│                                        2023-09-11 13:14:15.000 │
└────────────────────────────────────────────────────────────────┘

addDate

導入バージョン: v23.9.0

指定した日付、日時、または文字列で表現された日付もしくは日時に、時間インターバルを加算します。加算した結果がデータ型の範囲外の値になる場合、結果は未定義です。

構文

addDate(datetime, interval)

引数

datetime — interval を加算する日付または日時。Date または Date32 または DateTime または DateTime64 または String
interval — 加算するインターバル。Interval

戻り値

datetime に interval を加算して得られる日付または日時を返します。Date または Date32 または DateTime または DateTime64

例

日付にインターバルを加算

SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)

┌─addDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│                                       2021-01-01 │
└──────────────────────────────────────────────────┘

addDays

導入バージョン: v1.1.0

指定した日数を、日付、日時、または文字列で表現された日付もしくは日時に加算します。

構文

addDays(datetime, num)

引数

datetime — 指定した日数を加算する対象の日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 加算する日数。(U)Int* または Float*

戻り値

datetime に num 日を加算した値を返します。Date または Date32 または DateTime または DateTime64

例

異なる日付型に日数を加算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addDays(date, 5) AS add_days_with_date,
    addDays(date_time, 5) AS add_days_with_date_time,
    addDays(date_time_string, 5) AS add_days_with_date_time_string

┌─add_days_with_date─┬─add_days_with_date_time─┬─add_days_with_date_time_string─┐
│         2024-01-06 │     2024-01-06 00:00:00 │        2024-01-06 00:00:00.000 │
└────────────────────┴─────────────────────────┴────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 day)

┌─plus(CAST('1998-06-16', 'Date'), toIntervalDay(10))─┐
│                                          1998-06-26 │
└─────────────────────────────────────────────────────┘

addHours

導入バージョン: v1.1.0

指定した時間数を、日付、日時、または文字列で表現された日付もしくは日時に加算します。

構文

addHours(datetime, num)

引数

datetime — 指定した時間数を加算する日付または日時。 Date or Date32 or DateTime or DateTime64 or String
num — 加算する時間数。 (U)Int* or Float*

戻り値

datetime に num 時間を加算した値を返します DateTime or DateTime64(3)

例

異なる日付型に時間を加算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addHours(date, 12) AS add_hours_with_date,
    addHours(date_time, 12) AS add_hours_with_date_time,
    addHours(date_time_string, 12) AS add_hours_with_date_time_string

┌─add_hours_with_date─┬─add_hours_with_date_time─┬─add_hours_with_date_time_string─┐
│ 2024-01-01 12:00:00 │      2024-01-01 12:00:00 │         2024-01-01 12:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 hour)

┌─plus(CAST('1998-06-16', 'Date'), toIntervalHour(10))─┐
│                                  1998-06-16 10:00:00 │
└──────────────────────────────────────────────────────┘

addInterval

導入バージョン: v22.11.0

あるインターバルを、別のインターバルまたはインターバルのタプルに加算します。

構文

addInterval(interval_1, interval_2)

引数

interval_1 — 最初のインターバル、または複数のインターバルからなるタプルです。 Interval または Tuple(Interval)
interval_2 — 加算対象の 2 番目のインターバルです。 Interval

戻り値

インターバルのタプル Tuple(Interval) を返します

例

インターバルの加算

SELECT addInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT addInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT addInterval(INTERVAL 2 DAY, INTERVAL 1 DAY)

┌─addInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,1)                                             │
└───────────────────────────────────────────────────┘
┌─addInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,1)                                                                │
└────────────────────────────────────────────────────────────────────────┘
┌─addInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (3)                                             │
└─────────────────────────────────────────────────┘

addMicroseconds

導入バージョン: v22.6.0

指定した数のマイクロ秒を、日時または文字列で表現された日時に加算します。

構文

addMicroseconds(datetime, num)

引数

datetime — 指定したマイクロ秒数を加算する日時。 DateTime または DateTime64 または String
num — 加算するマイクロ秒数。 (U)Int* または Float*

戻り値

date_time に num マイクロ秒を加算した値を返します。 DateTime64

例

異なる日時型にマイクロ秒を加算する

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addMicroseconds(date_time, 1000000) AS add_microseconds_with_date_time,
    addMicroseconds(date_time_string, 1000000) AS add_microseconds_with_date_time_string

┌─add_microseconds_with_date_time─┬─add_microseconds_with_date_time_string─┐
│      2024-01-01 00:00:01.000000 │             2024-01-01 00:00:01.000000 │
└─────────────────────────────────┴────────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 microsecond)

┌─plus(CAST('1998-06-16', 'DateTime'), toIntervalMicrosecond(10))─┐
│                                      1998-06-16 00:00:00.000010 │
└─────────────────────────────────────────────────────────────────┘

addMilliseconds

導入バージョン: v22.6.0

指定したミリ秒数を日時、または文字列で表現された日時に加算します。

構文

addMilliseconds(datetime, num)

引数

datetime — 指定したミリ秒数を加算する日時。DateTime または DateTime64 または String
num — 加算するミリ秒数。(U)Int* または Float*

戻り値

datetime に num ミリ秒を加算した値。DateTime64

例

異なる日時型にミリ秒を加算する

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addMilliseconds(date_time, 1000) AS add_milliseconds_with_date_time,
    addMilliseconds(date_time_string, 1000) AS add_milliseconds_with_date_time_string

┌─add_milliseconds_with_date_time─┬─add_milliseconds_with_date_time_string─┐
│         2024-01-01 00:00:01.000 │                2024-01-01 00:00:01.000 │
└─────────────────────────────────┴────────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 millisecond)

┌─plus(CAST('1998-06-16', 'DateTime'), toIntervalMillisecond(10))─┐
│                                         1998-06-16 00:00:00.010 │
└─────────────────────────────────────────────────────────────────┘

addMinutes

導入バージョン: v1.1.0

指定した分数を、日付、日時、または文字列で表現された日付もしくは日時に加算します。

構文

addMinutes(datetime, num)

引数

datetime — 指定した分を加算する対象の日時または日付。Date または Date32 または DateTime または DateTime64 または String
num — 加算する分数。(U)Int* または Float*

戻り値

datetime に num 分を加算した値を返します。DateTime または DateTime64(3)

例

異なる日付型に分を加算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addMinutes(date, 20) AS add_minutes_with_date,
    addMinutes(date_time, 20) AS add_minutes_with_date_time,
    addMinutes(date_time_string, 20) AS add_minutes_with_date_time_string

┌─add_minutes_with_date─┬─add_minutes_with_date_time─┬─add_minutes_with_date_time_string─┐
│   2024-01-01 00:20:00 │        2024-01-01 00:20:00 │           2024-01-01 00:20:00.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 minute)

┌─plus(CAST('1998-06-16', 'Date'), toIntervalMinute(10))─┐
│                                    1998-06-16 00:10:00 │
└────────────────────────────────────────────────────────┘

addMonths

導入バージョン: v1.1.0

指定した月数を、日付、日時、または文字列で表現された日付もしくは日時に加算します。

構文

addMonths(datetime, num)

引数

datetime — 指定した月数を加算する対象の日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 加算する月数。(U)Int* または Float*

戻り値

datetime に num か月を加算した値を返します。Date または Date32 または DateTime または DateTime64

例

さまざまな日付型に月を加算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addMonths(date, 6) AS add_months_with_date,
    addMonths(date_time, 6) AS add_months_with_date_time,
    addMonths(date_time_string, 6) AS add_months_with_date_time_string

┌─add_months_with_date─┬─add_months_with_date_time─┬─add_months_with_date_time_string─┐
│           2024-07-01 │       2024-07-01 00:00:00 │          2024-07-01 00:00:00.000 │
└──────────────────────┴───────────────────────────┴──────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 month)

┌─plus(CAST('1998-06-16', 'Date'), toIntervalMonth(10))─┐
│                                            1999-04-16 │
└───────────────────────────────────────────────────────┘

addNanoseconds

導入バージョン: v22.6.0

指定したナノ秒数を、日時または文字列で表現された日時に加算します。

構文

addNanoseconds(datetime, num)

引数

datetime — 指定したナノ秒数を加算する対象の日時。DateTime または DateTime64 または String
num — 加算するナノ秒数。(U)Int* または Float*

戻り値

datetime に num ナノ秒を加算した値を返します。 DateTime64

例

さまざまな日時型にナノ秒を加算する

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addNanoseconds(date_time, 1000) AS add_nanoseconds_with_date_time,
    addNanoseconds(date_time_string, 1000) AS add_nanoseconds_with_date_time_string

┌─add_nanoseconds_with_date_time─┬─add_nanoseconds_with_date_time_string─┐
│  2024-01-01 00:00:00.000001000 │         2024-01-01 00:00:00.000001000 │
└────────────────────────────────┴───────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 1000 nanosecond)

┌─plus(CAST('1998-06-16', 'DateTime'), toIntervalNanosecond(1000))─┐
│                                    1998-06-16 00:00:00.000001000 │
└──────────────────────────────────────────────────────────────────┘

addQuarters

導入バージョン: v20.1.0

日付、日時、または文字列で表現された日付もしくは日時に、指定した数の四半期を加算します。

構文

addQuarters(datetime, num)

引数

datetime — 指定した四半期数を加算する日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 加算する四半期数。(U)Int* または Float*

戻り値

datetime に num 四半期を加算した値を返します。Date または Date32 または DateTime または DateTime64

例

異なる日付型に四半期を加算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addQuarters(date, 1) AS add_quarters_with_date,
    addQuarters(date_time, 1) AS add_quarters_with_date_time,
    addQuarters(date_time_string, 1) AS add_quarters_with_date_time_string

┌─add_quarters_with_date─┬─add_quarters_with_date_time─┬─add_quarters_with_date_time_string─┐
│             2024-04-01 │         2024-04-01 00:00:00 │            2024-04-01 00:00:00.000 │
└────────────────────────┴─────────────────────────────┴────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 quarter)

┌─plus(CAST('1998-06-16', 'Date'), toIntervalQuarter(10))─┐
│                                              2000-12-16 │
└─────────────────────────────────────────────────────────┘

addSeconds

導入バージョン: v1.1.0

指定した秒数を、日付、日時、または文字列で表現された日付もしくは日時に加算します。

構文

addSeconds(datetime, num)

引数

datetime — 指定した秒数を加算する対象の日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 加算する秒数。(U)Int* または Float*

戻り値

datetime に num 秒を加算した値を返します。DateTime または DateTime64(3)

例

異なる日付型に秒を加算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addSeconds(date, 30) AS add_seconds_with_date,
    addSeconds(date_time, 30) AS add_seconds_with_date_time,
    addSeconds(date_time_string, 30) AS add_seconds_with_date_time_string

┌─add_seconds_with_date─┬─add_seconds_with_date_time─┬─add_seconds_with_date_time_string─┐
│   2024-01-01 00:00:30 │        2024-01-01 00:00:30 │           2024-01-01 00:00:30.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 second)

┌─plus(CAST('1998-06-16', 'Date'), toIntervalSecond(10))─┐
│                                    1998-06-16 00:00:10 │
└────────────────────────────────────────────────────────┘

addTupleOfIntervals

導入バージョン: v22.11.0

日付または日時に、インターバルのタプルを順に加算します。

構文

addTupleOfIntervals(datetime, intervals)

引数

datetime — インターバルを加算する対象の日付または日時。Date または Date32 または DateTime または DateTime64
intervals — datetime に加算するインターバルの Tuple。Tuple(Interval)

戻り値

intervals を加算した date を返します。Date または Date32 または DateTime または DateTime64

例

日付にインターバルの Tuple を加算する

WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))

┌─addTupleOfIntervals(date, (toIntervalDay(1), toIntervalMonth(1), toIntervalYear(1)))─┐
│                                                                           2019-02-02 │
└──────────────────────────────────────────────────────────────────────────────────────┘

addWeeks

導入バージョン: v1.1.0

指定した週数を、日付、日時、または文字列として表された日付もしくは日時に加算します。

構文

addWeeks(datetime, num)

引数

datetime — 指定した週数を加算する対象の日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 加算する週数。(U)Int* または Float*

戻り値

datetime に num 週を加算した値を返します。Date または Date32 または DateTime または DateTime64

例

さまざまな日付型に週を加算

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addWeeks(date, 5) AS add_weeks_with_date,
    addWeeks(date_time, 5) AS add_weeks_with_date_time,
    addWeeks(date_time_string, 5) AS add_weeks_with_date_time_string

┌─add_weeks_with_date─┬─add_weeks_with_date_time─┬─add_weeks_with_date_time_string─┐
│          2024-02-05 │      2024-02-05 00:00:00 │         2024-02-05 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 week)

┌─plus(CAST('1998-06-16', 'Date'), toIntervalWeek(10))─┐
│                                           1998-08-25 │
└──────────────────────────────────────────────────────┘

addYears

導入バージョン: v1.1.0

日付、日時、または文字列として表された日付もしくは日時に、指定した年数を加えます。

構文

addYears(datetime, num)

引数

datetime — 指定した年数を加算する対象の日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 加算する年数。(U)Int* または Float*

戻り値

datetime に num 年を加算した値。Date または Date32 または DateTime または DateTime64

例

異なる日付型に年を加算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addYears(date, 1) AS add_years_with_date,
    addYears(date_time, 1) AS add_years_with_date_time,
    addYears(date_time_string, 1) AS add_years_with_date_time_string

┌─add_years_with_date─┬─add_years_with_date_time─┬─add_years_with_date_time_string─┐
│          2025-01-01 │      2025-01-01 00:00:00 │         2025-01-01 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 year)

┌─plus(CAST('1998-06-16', 'Date'), toIntervalYear(10))─┐
│                                           2008-06-16 │
└──────────────────────────────────────────────────────┘

age

導入バージョン: v23.1.0

startdate と enddate の差における、指定した単位の部分を返します。差は 1 ナノ秒の精度で計算されます。

たとえば、2021-12-29 と 2022-01-01 の差は、day 単位では 3 日、 month 単位では 0 か月、year 単位では 0 年です。

age の代替としては、関数 dateDiff を参照してください。

構文

age('unit', startdate, enddate[, timezone])

引数

unit — 結果の interval の種類。

Unit	設定可能な値
nanosecond	`nanosecond`, `nanoseconds`, `ns`
microsecond	`microsecond`, `microseconds`, `us`, `u`
millisecond	`millisecond`, `milliseconds`, `ms`
second	`second`, `seconds`, `ss`, `s`
minute	`minute`, `minutes`, `mi`, `n`
hour	`hour`, `hours`, `hh`, `h`
day	`day`, `days`, `dd`, `d`
week	`week`, `weeks`, `wk`, `ww`
month	`month`, `months`, `mm`, `m`
quarter	`quarter`, `quarters`, `qq`, `q`
year	`year`, `years`, `yyyy`, `yy`

startdate — 減算される最初の時刻値 (減数) 。Date または Date32 または DateTime または DateTime64
enddate — そこから減算する 2 番目の時刻値 (被減数) 。Date または Date32 または DateTime または DateTime64
timezone — 任意。タイムゾーン名です。指定した場合は、startdate と enddate の両方に適用されます。指定しない場合は、startdate と enddate のタイムゾーンが使用されます。両者が同一でない場合、結果は未定です。String

戻り値

unit で表した enddate と startdate の差を返します。Int32

例

年齢を時間単位で計算する

SELECT age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))

┌─age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))─┐
│                                                                                24 │
└───────────────────────────────────────────────────────────────────────────────────┘

さまざまな単位で年齢を計算する

SELECT
    toDate('2022-01-01') AS e,
    toDate('2021-12-29') AS s,
    age('day', s, e) AS day_age,
    age('month', s, e) AS month_age,
    age('year', s, e) AS year_age

┌──────────e─┬──────────s─┬─day_age─┬─month_age─┬─year_age─┐
│ 2022-01-01 │ 2021-12-29 │       3 │         0 │        0 │
└────────────┴────────────┴─────────┴───────────┴──────────┘

changeDay

導入バージョン: v24.7.0

日付または日時の「日」部分を変更します。

構文

changeDay(date_or_datetime, value)

引数

date_or_datetime — 変更対象の値。Date または Date32 または DateTime または DateTime64
value — 新しい値。(U)Int*

戻り値

時の部分が変更された、date_or_datetime と同じ型の値を返します。Date または Date32 または DateTime または DateTime64

例

使用例

SELECT changeDay('2024-01-31'::DateTime, 15)

2024-01-15 00:00:00

changeHour

導入バージョン: v24.7.0

日付または日時の時間部分を変更します。

構文

changeHour(date_or_datetime, value)

引数

date_or_datetime — 変更対象の値。Date または Date32 または DateTime または DateTime64
value — 新しい値。(U)Int*

戻り値

date_or_datetime と同じ型で、分の部分が変更された値を返します。DateTime または DateTime64

例

使用例

SELECT changeHour('2024-01-01 12:00:00'::DateTime, 5)

2024-01-01 05:00:00

changeMinute

導入バージョン: v24.7.0

日付または日時 の分部分を変更します。

構文

changeMinute(date_or_datetime, value)

引数

date_or_datetime — 変更対象の値です。Date または Date32 または DateTime または DateTime64
value — 新しい値です。(U)Int*

戻り値

分の部分が変更された、date_or_datetime と同じ型の値を返します。DateTime または DateTime64

例

使用例

SELECT changeMinute('2024-01-01 12:30:00'::DateTime, 45)

2024-01-01 12:45:00

changeMonth

導入バージョン: v24.7.0

日付または日時の月の部分を変更します。

構文

changeMonth(date_or_datetime, value)

引数

date_or_datetime — 変更対象の値です。Date または Date32 または DateTime または DateTime64
value — 新しい値です。(U)Int*

戻り値

date_or_datetime と同じ型で、月の部分が変更された値を返します。Date または Date32 または DateTime または DateTime64

例

使用例

SELECT changeMonth('2024-01-01'::DateTime, 12)

2024-12-01 00:00:00

changeSecond

導入バージョン: v24.7.0

日付または日時の秒部分を変更します。

構文

changeSecond(date_or_datetime, value)

引数

date_or_datetime — 変更対象の値。Date または Date32 または DateTime または DateTime64
value — 新しい値。(U)Int*

戻り値

秒の部分が変更された、date_or_datetime と同じ型の値を返します。DateTime または DateTime64

例

使用例

SELECT changeSecond('2024-01-01 12:30:45'::DateTime, 15)

2024-01-01 12:30:15

changeYear

導入バージョン: v24.7.0

日付または日時の年の部分を変更します。

構文

changeYear(date_or_datetime, value)

引数

date_or_datetime — 変更対象の値。Date または Date32 または DateTime または DateTime64
value — 新しい値。(U)Int*

戻り値

date_or_datetime と同じ型で、年の部分が変更された値を返します。Date または Date32 または DateTime または DateTime64

例

使用例

SELECT changeYear('2024-01-01'::DateTime, 2023)

2023-01-01 00:00:00

dateDiff

導入バージョン: v23.4.0

指定した unit について、startdate と enddate の間でまたいだ境界の数を返します。差は相対単位を用いて計算されます。たとえば、2021-12-29 と 2022-01-01 の差は、unit day では 3 日です (toRelativeDayNum を参照) 。unit month では 1 か月、unit year では 1 年です (それぞれ toRelativeMonthNum、toRelativeYearNum を参照) 。

unit に week を指定した場合、dateDiff は週の開始日を月曜日とみなします。この動作は、既定で週の開始日が日曜日である関数 toWeek() とは異なることに注意してください。

dateDiff の代わりに、関数 age も使用できます。

構文

dateDiff(unit, startdate, enddate[, timezone])

別名: timestampDiff, TIMESTAMP_DIFF, DATE_DIFF, date_diff, timestamp_diff

引数

unit — 結果を表す interval の種類。

Unit	設定可能な値
nanosecond	`nanosecond`, `nanoseconds`, `ns`
microsecond	`microsecond`, `microseconds`, `us`, `u`
millisecond	`millisecond`, `milliseconds`, `ms`
second	`second`, `seconds`, `ss`, `s`
minute	`minute`, `minutes`, `mi`, `n`
hour	`hour`, `hours`, `hh`, `h`
day	`day`, `days`, `dd`, `d`
week	`week`, `weeks`, `wk`, `ww`
month	`month`, `months`, `mm`, `m`
quarter	`quarter`, `quarters`, `qq`, `q`
year	`year`, `years`, `yyyy`, `yy`

startdate — 減算される最初の時刻値 (減数) 。Date または Date32 または DateTime または DateTime64
enddate — 減算元となる 2 番目の時刻値 (被減数) 。Date または Date32 または DateTime または DateTime64
timezone — 任意。タイムゾーン名。指定した場合は、startdate と enddate の両方に適用されます。指定しない場合は、startdate と enddate のタイムゾーンが使用されます。両者が同一でない場合、結果は未定義です。String

戻り値

unit で表した enddate と startdate の差を返します。Int64

例

日付の差を時間単位で計算する

SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res

┌─res─┐
│  25 │
└─────┘

さまざまな単位で日付の差分を計算する

SELECT
    toDate('2022-01-01') AS e,
    toDate('2021-12-29') AS s,
    dateDiff('day', s, e) AS day_diff,
    dateDiff('month', s, e) AS month_diff,
    dateDiff('year', s, e) AS year_diff

┌──────────e─┬──────────s─┬─day_diff─┬─month_diff─┬─year_diff─┐
│ 2022-01-01 │ 2021-12-29 │        3 │          1 │         1 │
└────────────┴────────────┴──────────┴────────────┴───────────┘

dateName

導入バージョン: v21.7.0

指定した日付の部分を返します。

設定可能な値:

'year'
'quarter'
'month'
'week'
'dayofyear'
'day'
'weekday'
'hour'
'minute'
'second'

構文

dateName(date_part, date[, timezone])

引数

date_part — 抽出する日付要素です。 String
datetime — 日付または日時の値です。 Date または Date32 または DateTime または DateTime64
timezone — 省略可能。タイムゾーンです。 String

戻り値

指定した日付要素を返します。 String

例

さまざまな日付要素を抽出する

WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT
    dateName('year', date_value),
    dateName('month', date_value),
    dateName('day', date_value)

┌─dateName('year', date_value)─┬─dateName('month', date_value)─┬─dateName('day', date_value)─┐
│ 2021                         │ April                         │ 14                          │
└──────────────────────────────┴───────────────────────────────┴─────────────────────────────┘

dateTrunc

導入バージョン: v20.8.0

日付と時刻の値を、指定した日付の単位で切り捨てます。

構文

dateTrunc(unit, datetime[, timezone])

別名: DATE_TRUNC

引数

unit — 結果を切り捨てる単位となる interval の種類。設定可能な値: nanosecond (DateTime64 のみ) 、microsecond (DateTime64 のみ) 、millisecond (DateTime64 のみ) 、second、minute、hour、day、week、month、quarter、year。 String
datetime — 日付と時刻。Date または Date32 または DateTime または DateTime64
timezone — 任意。戻り値の日時に使用するタイムゾーン名です。指定しない場合、関数は datetime 引数のタイムゾーンを使用します。String

戻り値

切り捨て後の日付・時刻の値を返します。

Unit Argument	`datetime` Argument	Return Type
Year, Quarter, Month, Week	`Date32` or `DateTime64` or `Date` or `DateTime`	`Date32` or `Date`
Day, Hour, Minute, Second	`Date32`, `DateTime64`, `Date`, or `DateTime`	`DateTime64` or `DateTime`
Millisecond, Microsecond,	Any	`DateTime64`
Nanosecond		with scale 3, 6, or 9

例

タイムゾーンを指定せずに切り捨てる

SELECT now(), dateTrunc('hour', now());

┌───────────────now()─┬─dateTrunc('hour', now())──┐
│ 2020-09-28 10:40:45 │       2020-09-28 10:00:00 │
└─────────────────────┴───────────────────────────┘

指定したタイムゾーンで切り捨てる

SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul');

┌───────────────now()─┬─dateTrunc('hour', now(), 'Asia/Istanbul')──┐
│ 2020-09-28 10:46:26 │                        2020-09-28 13:00:00 │
└─────────────────────┴────────────────────────────────────────────┘

formatDateTime

導入バージョン: v1.1.0

指定したフォーマット文字列に従って、日付または日時をフォーマットします。format は定数式であるため、1 つの結果カラムに対して複数のフォーマットを指定することはできません。

formatDateTime は MySQL の datetime フォーマットスタイルを使用します。詳しくは mysql docs を参照してください。

この関数の逆の操作を行うのは parseDateTime です。

置換フィールドを使用すると、結果の文字列のパターンを定義できます。以下の表の Example カラムは、2018-01-02 22:33:44 をフォーマットした結果を示しています。

置換フィールド:

Placeholder	Description	Example
%a	省略形の曜日名 (Mon-Sun)	Mon
%b	省略形の月名 (Jan-Dec)	Jan
%c	月を整数で表したもの (01-12)	01
%C	年を 100 で割って整数に切り捨てた値 (00-99)	20
%d	日。ゼロ埋め (01-31)	02
%D	短い MM/DD/YY 形式の日付。%m/%d/%y と同等	01/02/18
%e	日。空白埋め (1-31)	2
%f	秒の小数部	123456
%F	短い YYYY-MM-DD 形式の日付。%Y-%m-%d と同等	2018-01-02
%g	ISO 8601 に準拠した 2 桁の年形式	18
%G	ISO の週番号に対応する 4 桁の年形式	2018
%h	12 時間形式の時 (01-12)	09
%H	24 時間形式の時 (00-23)	22
%i	分 (00-59)	33
%I	12 時間形式の時 (01-12)	10
%j	年内通算日 (001-366)	002
%k	24 時間形式の時 (00-23)	14
%l	12 時間形式の時 (01-12)	09
%m	月を整数で表したもの (01-12)	01
%M	完全な月名 (January-December)	January
%n	改行文字
%p	AM または PM 表記	PM
%Q	四半期 (1-4)	1
%r	12 時間 HH:MM AM/PM 形式の時刻。%h:%i %p と同等	10:30 PM
%R	24 時間 HH:MM 形式の時刻。%H:%i と同等	22:33
%s	秒 (00-59)	44
%S	秒 (00-59)	44
%t	水平タブ文字
%T	ISO 8601 時刻形式 (HH:MM:SS)。%H:%i:%S と同等	22:33:44
%u	月曜を 1 とする ISO 8601 の曜日番号 (1-7)	2
%V	ISO 8601 の週番号 (01-53)	01
%w	日曜を 0 とする整数の曜日番号 (0-6)	2
%W	完全な曜日名 (Monday-Sunday)	Monday
%y	年の下 2 桁 (00-99)	18
%Y	年	2018
%z	UTC からの時差。+HHMM または -HHMM	-0500
%%	% 記号	%

ClickHouse v23.4 より前では、フォーマット対象の値が Date、Date32、DateTime (これらには秒の小数部がありません) 、または精度 0 の DateTime64 の場合、%f は単一のゼロ (0) を出力します。
ClickHouse v25.1 より前では、%f は固定の 6 桁ではなく、DateTime64 の scale で指定された桁数だけ出力します。
ClickHouse v23.4 より前では、%M は完全な月名 (January-December) ではなく、分 (00-59) を出力します。

構文

formatDateTime(datetime, format[, timezone])

別名: DATE_FORMAT

引数

datetime — フォーマット対象の日付または日時。Date または Date32 または DateTime または DateTime64
format — 置換フィールドを含むフォーマット文字列。String
timezone — 任意。フォーマットする時刻に使用するタイムゾーン名。String

戻り値

指定したフォーマットに従った日時の値を返します。String

例

年のプレースホルダーを使って日付をフォーマットする

SELECT formatDateTime(toDate('2010-01-04'), '%g')

┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10                                         │
└────────────────────────────────────────────┘

小数秒付きの DateTime64 をフォーマットする

SELECT formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')

┌─formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')─┐
│ 123456                                                              │
└─────────────────────────────────────────────────────────────────────┘

タイムゾーン付きのフォーマット

SELECT
    now() AS ts,
    time_zone,
    formatDateTime(ts, '%T', time_zone) AS str_tz_time
FROM system.time_zones
WHERE time_zone LIKE 'Europe%'
LIMIT 10

┌──────────────────ts─┬─time_zone─────────┬─str_tz_time─┐
│ 2023-09-08 19:13:40 │ Europe/Amsterdam  │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Andorra    │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Astrakhan  │ 23:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Athens     │ 22:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Belfast    │ 20:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Belgrade   │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Berlin     │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Bratislava │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Brussels   │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Bucharest  │ 22:13:40    │
└─────────────────────┴───────────────────┴─────────────┘

formatDateTimeInJodaSyntax

導入バージョン: v20.1.0

formatDateTimeに似ていますが、MySQL形式ではなくJoda形式で日時をフォーマットする点が異なります。Joda Timeのドキュメントを参照してください。

この関数の逆の操作は、parseDateTimeInJodaSyntaxです。

置換フィールドを使用すると、結果文字列のパターンを定義できます。

置換フィールド:

プレースホルダー	説明	表示形式	例
G	紀元	テキスト	AD
C	紀元の世紀 (>=0)	数値	20
Y	紀元の年 (>=0)	年	1996
x	週ベース年 (未対応)	年	1996
w	週ベース年の週 (未対応)	数値	27
e	曜日	数値	2
E	曜日	テキスト	Tuesday; Tue
y	年	年	1996
D	年内通算日	数値	189
M	月	月	July; Jul; 07
d	日	数値	10
a	午前/午後	テキスト	PM
K	午前/午後の時 (0~11)	数値	0
h	午前/午後の時刻 (1~12)	数値	12
H	時 (0~23)	数値	0
k	時刻 (1~24)	数値	24
m	分	数値	30
s	秒	数値	55
S	秒の小数部	数値	978
z	タイムゾーン	テキスト	Eastern Standard Time; EST
Z	タイムゾーンオフセット	ゾーン	-0800; -0812
'	テキストのエスケープ	区切り文字
''	単一引用符	リテラル	'

構文

formatDateTimeInJodaSyntax(datetime, format[, timezone])

引数

datetime — フォーマットする日付または日時。DateTime または Date または Date32 または DateTime64
format — Joda形式の置換フィールドを含むフォーマット文字列。String
timezone — 任意。フォーマットする時刻に使用するタイムゾーン名。String

戻り値

指定したフォーマットに従った日時の値を返します。String

例

Joda構文を使用して datetime をフォーマットする

SELECT formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')

┌─formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')─┐
│ 2010-01-04 12:34:56                                                                  │
└──────────────────────────────────────────────────────────────────────────────────────┘

fromDaysSinceYearZero

導入バージョン: v23.11.0

0000年1月1日からの経過日数を指定すると、対応するISO 8601 で定義されたプロレプティック・グレゴリオ暦の日付を返します。

計算方法は MySQL の FROM_DAYS() 関数と同じです。Date 型の範囲内で表現できない場合、結果は未定義です。

構文

fromDaysSinceYearZero(days)

別名: FROM_DAYS

引数

days — 紀元 0 年からの経過日数。UInt32

戻り値

紀元 0 年からの経過日数に対応する日付を返します。Date

例

紀元 0 年からの日数を日付に変換

SELECT
fromDaysSinceYearZero(739136) AS date1,
fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2

┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘

fromDaysSinceYearZero32

導入バージョン: v23.11.0

0000 年 1 月 1 日からの経過日数を指定すると、ISO 8601 で定義されるプロレプティック・グレゴリオ暦における対応する日付を返します。この計算は MySQL の FROM_DAYS() 関数と同じです。結果が Date32 型の範囲内で表現できない場合、結果は未定義です。

構文

fromDaysSinceYearZero32(days)

引数

days — 紀元0年からの経過日数。UInt32

戻り値

紀元0年からの経過日数に対応する日付を返します。Date32

例

紀元0年からの経過日数を日付に変換する

SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2

┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘

fromModifiedJulianDay

導入バージョン: v21.1.0

修正ユリウス日の数値を、YYYY-MM-DD 形式のテキストによるプロレプティック・グレゴリオ暦の日付に変換します。この関数は、-678941 から 2973483 までの日数をサポートします (それぞれ 0000-01-01 と 9999-12-31 を表します) 。日数がサポート対象の範囲外の場合は例外を返します。

構文

fromModifiedJulianDay(day)

引数

day — 修正ユリウス日の日数。(U)Int*

戻り値

テキスト形式の日付を返します。String

例

修正ユリウス日を日付に変換

SELECT fromModifiedJulianDay(58849)

┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01                   │
└──────────────────────────────┘

fromModifiedJulianDayOrNull

導入バージョン: v21.1.0

fromModifiedJulianDay() と同様ですが、例外をスローする代わりに NULL を返します。

構文

fromModifiedJulianDayOrNull(day)

引数

day — 修正ユリウス日の日数。(U)Int*

戻り値

day 引数が有効な場合はテキスト形式の日付を返し、それ以外の場合は null を返します。Nullable(String)

例

null を処理しながら修正ユリウス日を日付に変換する

SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- invalid argument, returns NULL

┌─fromModifiedJulianDayOrNull(58849)─┐
│ 2020-01-01                         │
└────────────────────────────────────┘
┌─fromModifiedJulianDayOrNull(60000000)─┐
│ ᴺᵁᴸᴸ                                  │
└───────────────────────────────────────┘

fromUTCTimestamp

導入バージョン: v22.1.0

UTC タイムゾーンの date または日時の値を、指定したタイムゾーンの date または日時の値に変換します。この関数は主に、Apache Spark や同様のフレームワークとの互換性のために用意されています。

構文

fromUTCTimestamp(datetime, time_zone)

別名: from_utc_timestamp

引数

datetime — 日付または日時の定数値、あるいは式。DateTime または DateTime64
time_zone — タイムゾーンを表す String 型の定数値、または式。String

戻り値

指定したタイムゾーンの DateTime/DateTime64 を返します。DateTime または DateTime64

例

UTCタイムゾーンを指定したタイムゾーンに変換します

SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')

┌─fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')─┐
│                                                   2023-03-16 18:00:00.000 │
└───────────────────────────────────────────────────────────────────────────┘

fromUnixTimestamp

導入バージョン: v20.8.0

この関数は、Unixタイムスタンプをカレンダー日付と時刻に変換します。

この関数は、次の 2 通りの方法で呼び出せます。

型 Integer の単一の引数が指定された場合、型 DateTime の値を返します。つまり、toDateTime と同様に動作します。
2 つまたは 3 つの引数が指定され、1 番目の引数が型 Integer、Date、Date32、DateTime、または DateTime64 の値で、2 番目の引数が定数の書式文字列、3 番目の引数が省略可能な定数のタイムゾーン文字列である場合、この関数は型 String の値を返します。つまり、formatDateTime と同様に動作します。この場合、MySQL の datetime フォーマットスタイルが使用されます。

構文

fromUnixTimestamp(timestamp)
fromUnixTimestamp(timestamp[, format[, timezone]])

別名: FROM_UNIXTIME

引数

timestamp — Unixタイムスタンプまたは date/日時の値。(U)Int* または Date または Date32 または DateTime または DateTime64
format — 任意。出力のフォーマットに使用する定数のフォーマット文字列。String
timezone — 任意。定数のタイムゾーン文字列。String

戻り値

引数が 1 つの場合は timestamp の DateTime を返し、引数が 2 つまたは 3 つの場合は String を返します。DateTime または String

例

Unixタイムスタンプを DateTime に変換する

SELECT fromUnixTimestamp(423543535)

┌─fromUnixTimestamp(423543535)─┐
│          1983-06-04 02:58:55 │
└──────────────────────────────┘

フォーマットを指定して Unixタイムスタンプを変換

SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime

┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘

fromUnixTimestampInJodaSyntax

導入バージョン: v23.1.0

この関数は、Unixタイムスタンプを日付と時刻に変換します。

この関数は、2通りの方法で呼び出せます。

型 Integer の単一の引数が与えられた場合、型 DateTime の値を返します。つまり、toDateTime と同様に動作します。

2つまたは3つの引数が与えられ、1番目の引数が型 Integer、Date、Date32、DateTime または DateTime64 の値であり、2番目の引数が定数のフォーマット文字列、3番目の引数が省略可能な定数のタイムゾーン文字列である場合、この関数は型 String の値を返します。つまり、formatDateTimeInJodaSyntax と同様に動作します。この場合、Joda の日時フォーマットスタイルが使用されます。

構文

fromUnixTimestampInJodaSyntax(timestamp)
fromUnixTimestampInJodaSyntax(timestamp, format[, timezone])

引数

timestamp — Unixタイムスタンプまたは日時の値。 (U)Int* または Date または Date32 または DateTime または DateTime64
format — 省略可能。出力のフォーマットに使用する、Joda構文による定数のフォーマット文字列。 String
timezone — 省略可能。定数のタイムゾーン文字列。 String

戻り値

引数が 1 つの場合は日時を返し、引数が 2 つまたは 3 つの場合は String を返します。} DateTime または String

例

Jodaフォーマットで Unixタイムスタンプを変換

SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime

┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘

localtime

導入バージョン: v26.7.0

クエリ解析時点における、サーバー (またはセッション) のタイムゾーンでの現在の時刻を返します。この関数は定数式です。SQL 標準 / PostgreSQL の LOCALTIME であり、CAST(now() AS Time) と等価です。

構文

localtime()

引数

なし。

戻り値

現在の時刻を返します。Time

例

SQL 標準構文

SELECT LOCALTIME

┌───────LOCALTIME─┐
│        07:42:09 │
└─────────────────┘

makeDate

導入バージョン: v22.6.0

Date を、次のいずれかから作成します。

年、月、日
年と年内通算日

構文

makeDate(year, month, day)
makeDate(year, day_of_year)

引数

year — 年。(U)Int* または Float* または Decimal
month — 月 (1-12) 。(U)Int* または Float* または Decimal
day — 日 (1-31) 。(U)Int* または Float* または Decimal
day_of_year — 年内通算日 (1-365) 。(U)Int* または Float* または Decimal

戻り値

指定された引数から構築された Date 値を返します Date

例

年、月、日から日付を作成

SELECT makeDate(2023, 2, 28) AS date;

┌───────date─┐
│ 2023-02-28 │
└────────────┘

年と年内通算日から日付を作成

SELECT makeDate(2023, 42) AS date;

┌───────date─┐
│ 2023-02-11 │
└────────────┘

makeDate32

導入バージョン: v22.6.0

以下のいずれかから Date32 を生成します。

年、月、日
年と年内通算日

構文

makeDate32(year, month, day)
makeDate32(year, day_of_year)

引数

year — 年を表す数値。(U)Int* または Float* または Decimal
month — 月を表す数値 (1～12) 。(U)Int* または Float* または Decimal
day — 日を表す数値 (1～31) 。(U)Int* または Float* または Decimal
day_of_year — 年内通算日 (1～365) 。(U)Int* または Float* または Decimal

戻り値

指定した引数から生成された Date32 型の値を返します。Date32

例

年、月、日から Date32 を生成

SELECT makeDate(2023, 2, 28) AS date;

┌───────date─┐
│ 2023-02-28 │
└────────────┘

年と年内通算日からDate32を作成

SELECT makeDate(2023, 42) AS date;

┌───────date─┐
│ 2023-02-11 │
└────────────┘

makeDateTime

導入バージョン: v22.6.0

年、月、日、時、分、秒、および任意の timezone から DateTime を作成します。

構文

makeDateTime(year, month, day, hour, minute, second[, timezone])

引数

year — 年。 (U)Int* または Float* または Decimal
month — 月 (1～12) 。 (U)Int* または Float* または Decimal
day — 日 (1～31) 。 (U)Int* または Float* または Decimal
hour — 時 (0～23) 。 (U)Int* または Float* または Decimal
minute — 分 (0～59) 。 (U)Int* または Float* または Decimal
second — 秒 (0～59) 。 (U)Int* または Float* または Decimal
timezone — タイムゾーン名。 String

戻り値

指定された引数から構築された DateTime 値を返します。 DateTime

例

年、月、日、時、分、秒から DateTime を構築

SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;

┌────────────DateTime─┐
│ 2023-02-28 17:12:33 │
└─────────────────────┘

makeDateTime64

導入バージョン: v22.6.0

年、月、日、時、分、秒に、オプションで小数部、精度、タイムゾーンを指定して DateTime64 を作成します。

構文

makeDateTime64(year, month, day, hour, minute, second[, fraction[, precision[, timezone]]])

引数

year — 年。 (U)Int* または Float* または Decimal
month — 月 (1-12) 。 (U)Int* または Float* または Decimal
day — 日 (1-31) 。 (U)Int* または Float* または Decimal
hour — 時 (0-23) 。 (U)Int* または Float* または Decimal
minute — 分 (0-59) 。 (U)Int* または Float* または Decimal
second — 秒 (0-59) 。 (U)Int* または Float* または Decimal
fraction — 秒の小数部。 (U)Int* または Float* または Decimal
precision — 小数部の精度 (0-9) 。 UInt8
timezone — タイムゾーン名。 String

戻り値

指定された引数から構築された DateTime64 値を返します

例

年、月、日、時、分、秒から DateTime64 を作成

SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);

┌─makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5)─┐
│                       2023-05-15 10:30:45.00779 │
└─────────────────────────────────────────────────┘

monthName

導入バージョン: v22.1.0

日付または日時の値から、月名を文字列で返します。

構文

monthName(datetime)

引数

datetime — 日付または日時。Date または Date32、DateTime または DateTime64

戻り値

月名を返します。String

例

日付から月名を取得する

WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)

┌─monthName(date_value)─┐
│ April                 │
└───────────────────────┘

now

導入バージョン: v1.1.0

クエリの解析時点における現在の日付と時刻を返します。この関数は定数式です。

構文

now([timezone])

別名: localtimestamp, current_timestamp

引数

timezone — 任意。戻り値のタイムゾーン名。String

戻り値

現在の日付と時刻を返します。DateTime

例

タイムゾーンを指定しないクエリ

SELECT now()

┌───────────────now()─┐
│ 2020-10-17 07:42:09 │
└─────────────────────┘

タイムゾーンを指定してクエリを実行

SELECT now('Asia/Istanbul')

┌─now('Asia/Istanbul')─┐
│  2020-10-17 10:42:23 │
└──────────────────────┘

SQL 標準構文

SELECT NOW, CURRENT_TIMESTAMP

┌─────────────────NOW─┬───CURRENT_TIMESTAMP─┐
│ 2020-10-17 07:42:19 │ 2020-10-17 07:42:19 │
└─────────────────────┴─────────────────────┘

now64

導入バージョン: v20.1.0

クエリ解析時点の、秒未満の精度を持つ現在の日付と時刻を返します。この関数は定数式です。

構文

now64([scale[, timezone]])

引数

scale — 任意。ティックサイズ (精度) ：10^-precision 秒。有効範囲: [0 : 9]。通常は 3 (デフォルト、ミリ秒) 、6 (マイクロ秒) 、9 (ナノ秒) が使用されます。UInt8
timezone — 任意。戻り値のタイムゾーン名。String

戻り値

サブ秒精度を持つ現在の日付と時刻を返します。DateTime64

例

デフォルトおよびカスタムの精度を指定したクエリ

SELECT now64(), now64(9, 'Asia/Istanbul')

┌─────────────────now64()─┬─────now64(9, 'Asia/Istanbul')─┐
│ 2022-08-21 19:34:26.196 │ 2022-08-21 22:34:26.196542766 │
└─────────────────────────┴───────────────────────────────┘

nowInBlock

導入バージョン: v22.8.0

各データブロックの処理時点における現在の日時を返します。関数 now とは異なり、これは定数式ではないため、長時間実行されるクエリではブロックごとに戻り値が異なります。

この関数は、長時間実行される INSERT SELECT クエリで現在時刻を生成する場合に適しています。

構文

nowInBlock([timezone])

引数

timezone — 省略可。戻り値のタイムゾーン名。String

戻り値

各データブロックの処理時点における現在の日付と時刻を返します。DateTime

例

now() 関数との違い

SELECT
    now(),
    nowInBlock(),
    sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock

┌───────────────now()─┬────────nowInBlock()─┬─sleep(1)─┐
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:19 │        0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:20 │        0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:21 │        0 │
└─────────────────────┴─────────────────────┴──────────┘

nowInBlock64

導入バージョン: v25.8.0

各データブロックの処理時点における現在の日時を、ミリ秒単位で返します。関数 now64 とは異なり、これは定数式ではないため、長時間実行されるクエリではブロックごとに戻り値が異なります。

この関数は、長時間実行される INSERT SELECT クエリで現在時刻を生成する場合に適しています。

構文

nowInBlock64([scale[, timezone]])

引数

scale — 任意。ティックサイズ (精度) : 10^-precision 秒。有効範囲: [0 : 9]。通常使用されるのは 3 (デフォルト、ミリ秒) 、6 (マイクロ秒) 、9 (ナノ秒) です。UInt8
timezone — 任意。戻り値のタイムゾーン名。String

戻り値

各データブロックの処理時点における現在の日付と時刻を、秒未満の精度で返します。DateTime64

例

now64() 関数との違い

SELECT
    now64(),
    nowInBlock64(),
    sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock

┌─────────────────now64()─┬──────────nowInBlock64()─┬─sleep(1)─┐
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:29.534 │        0 │
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:30.535 │        0 │
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:31.535 │        0 │
└─────────────────────────┴─────────────────────────┴──────────┘

serverTimezone

導入バージョン: v23.6.0

server のタイムゾーン、つまり timezone 設定の値を返します。この関数が分散テーブルのコンテキストで実行される場合、各分片に対応する値を持つ通常のカラムを返します。そうでない場合は、定数値を返します。

構文

serverTimezone()

別名: serverTimeZone

引数

なし。

戻り値

サーバーのタイムゾーンを String で返します

例

使用例

SELECT serverTimeZone()

┌─serverTimeZone()─┐
│ Etc/UTC          │
└──────────────────┘

subDate

導入バージョン: v23.9.0

指定された日付、日時、または日付/日時を文字列で表した値から、時間間隔を減算します。減算の結果がデータ型の範囲外の値になった場合、結果は未定義です。

構文

subDate(datetime, interval)

引数

datetime — interval を減算する日付または日時。Date または Date32 または DateTime または DateTime64
interval — 減算するインターバル。Interval

戻り値

datetime から interval を減算して得られる日付または日時を返します。Date または Date32 または DateTime または DateTime64

例

日付から interval を減算する

SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR)

┌─subDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│                                       2015-01-01 │
└──────────────────────────────────────────────────┘

subtractDays

導入バージョン: v1.1.0

date、日時、または date / 日時を表す文字列から、指定した日数を減算します。

構文

subtractDays(datetime, num)

引数

datetime — 指定した日数を減算する対象の日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 減算する日数。(U)Int* または Float*

戻り値

datetime から num 日を減算した値を返します。Date または Date32 または DateTime または DateTime64

例

異なる日付型から日数を減算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractDays(date, 31) AS subtract_days_with_date,
    subtractDays(date_time, 31) AS subtract_days_with_date_time,
    subtractDays(date_time_string, 31) AS subtract_days_with_date_time_string

┌─subtract_days_with_date─┬─subtract_days_with_date_time─┬─subtract_days_with_date_time_string─┐
│              2023-12-01 │          2023-12-01 00:00:00 │             2023-12-01 00:00:00.000 │
└─────────────────────────┴──────────────────────────────┴─────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 day)

┌─minus(CAST('1998-06-16', 'Date'), toIntervalDay(10))─┐
│                                           1998-06-06 │
└──────────────────────────────────────────────────────┘

subtractHours

導入バージョン: v1.1.0

日付、日時、または文字列で表された日付もしくは日時から、指定した時間数を差し引きます。

構文

subtractHours(datetime, num)

引数

datetime — 指定した時間数を減算する日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 減算する時間数。(U)Int* または Float*

戻り値

datetime から num 時間を引いた結果。DateTime または DateTime64(3)

例

異なる日付型から時間を減算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractHours(date, 12) AS subtract_hours_with_date,
    subtractHours(date_time, 12) AS subtract_hours_with_date_time,
    subtractHours(date_time_string, 12) AS subtract_hours_with_date_time_string

┌─subtract_hours_with_date─┬─subtract_hours_with_date_time─┬─subtract_hours_with_date_time_string─┐
│      2023-12-31 12:00:00 │           2023-12-31 12:00:00 │              2023-12-31 12:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 hour)

┌─minus(CAST('1998-06-16', 'Date'), toIntervalHour(10))─┐
│                                   1998-06-15 14:00:00 │
└───────────────────────────────────────────────────────┘

subtractInterval

導入バージョン: v22.11.0

負のインターバルを、別のインターバルまたはインターバルのタプルに加算します。

注: 同じ型のインターバルは 1 つのインターバルにまとめられます。たとえば、toIntervalDay(2) と toIntervalDay(1) を渡した場合、結果は (2,1) ではなく (1) になります。

構文

subtractInterval(interval_1, interval_2)

引数

interval_1 — 1 つ目のインターバル、またはインターバルのタプル。Interval または Tuple(Interval)
interval_2 — 符号を反転する 2 つ目のインターバル。Interval

戻り値

インターバルのタプル Tuple(T) を返します

例

インターバルを減算する

SELECT subtractInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT subtractInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT subtractInterval(INTERVAL 2 DAY, INTERVAL 1 DAY);

┌─subtractInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,-1)                                                 │
└────────────────────────────────────────────────────────┘
┌─subtractInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,-1)                                                                    │
└─────────────────────────────────────────────────────────────────────────────┘
┌─subtractInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (1)                                                  │
└──────────────────────────────────────────────────────┘

subtractMicroseconds

導入バージョン: v22.6.0

日時、または文字列としてエンコードされた日時から、指定した数のマイクロ秒を減算します。

構文

subtractMicroseconds(datetime, num)

引数

datetime — 指定した数のマイクロ秒を減算する対象の日時。DateTime または DateTime64 または String
num — 減算するマイクロ秒数。(U)Int* または Float*

戻り値

datetime から num マイクロ秒を減算した値を返します。DateTime64

例

さまざまな日時型からマイクロ秒を減算する

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractMicroseconds(date_time, 1000000) AS subtract_microseconds_with_date_time,
    subtractMicroseconds(date_time_string, 1000000) AS subtract_microseconds_with_date_time_string

┌─subtract_microseconds_with_date_time─┬─subtract_microseconds_with_date_time_string─┐
│           2023-12-31 23:59:59.000000 │                  2023-12-31 23:59:59.000000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 microsecond)

┌─minus(CAST('1998-06-16', 'DateTime'), toIntervalMicrosecond(10))─┐
│                                       1998-06-15 23:59:59.999990 │
└──────────────────────────────────────────────────────────────────┘

subtractMilliseconds

導入バージョン: v22.6.0

日時、または文字列としてエンコードされた日時から、指定したミリ秒数を減算します。

構文

subtractMilliseconds(datetime, num)

引数

datetime — 指定したミリ秒数を減算する日時。DateTime または DateTime64 または String
num — 減算するミリ秒数。(U)Int* または Float*

戻り値

datetime から num ミリ秒を減算した値を返します。DateTime64

例

さまざまな日時型からミリ秒を減算する

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractMilliseconds(date_time, 1000) AS subtract_milliseconds_with_date_time,
    subtractMilliseconds(date_time_string, 1000) AS subtract_milliseconds_with_date_time_string

┌─subtract_milliseconds_with_date_time─┬─subtract_milliseconds_with_date_time_string─┐
│              2023-12-31 23:59:59.000 │                     2023-12-31 23:59:59.000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 millisecond)

┌─minus(CAST('1998-06-16', 'DateTime'), toIntervalMillisecond(10))─┐
│                                          1998-06-15 23:59:59.990 │
└──────────────────────────────────────────────────────────────────┘

subtractMinutes

導入バージョン: v1.1.0

日付、日時、または文字列で表現された日付もしくは日時から、指定した分数の分を減算します。

構文

subtractMinutes(datetime, num)

引数

datetime — 指定した分数を減算する対象の日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 減算する分数。(U)Int* または Float*

戻り値

datetime から num 分を減算した値を返します。DateTime または DateTime64(3)

例

さまざまな日付型から分を減算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractMinutes(date, 30) AS subtract_minutes_with_date,
    subtractMinutes(date_time, 30) AS subtract_minutes_with_date_time,
    subtractMinutes(date_time_string, 30) AS subtract_minutes_with_date_time_string

┌─subtract_minutes_with_date─┬─subtract_minutes_with_date_time─┬─subtract_minutes_with_date_time_string─┐
│        2023-12-31 23:30:00 │             2023-12-31 23:30:00 │                2023-12-31 23:30:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 minute)

┌─minus(CAST('1998-06-16', 'Date'), toIntervalMinute(10))─┐
│                                     1998-06-15 23:50:00 │
└─────────────────────────────────────────────────────────┘

subtractMonths

導入バージョン: v1.1.0

日付、日時、または文字列として表現された日付もしくは日時から、指定した月数を減算します。

構文

subtractMonths(datetime, num)

引数

datetime — 指定した月数を減算する対象の日付または日時。 Date または Date32 または DateTime または DateTime64 または String
num — 減算する月数。 (U)Int* または Float*

戻り値

datetime から num か月を減算した値。 Date または Date32 または DateTime または DateTime64

例

さまざまな日付型から月を減算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractMonths(date, 1) AS subtract_months_with_date,
    subtractMonths(date_time, 1) AS subtract_months_with_date_time,
    subtractMonths(date_time_string, 1) AS subtract_months_with_date_time_string

┌─subtract_months_with_date─┬─subtract_months_with_date_time─┬─subtract_months_with_date_time_string─┐
│                2023-12-01 │            2023-12-01 00:00:00 │               2023-12-01 00:00:00.000 │
└───────────────────────────┴────────────────────────────────┴───────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 month)

┌─minus(CAST('1998-06-16', 'Date'), toIntervalMonth(10))─┐
│                                             1997-08-16 │
└────────────────────────────────────────────────────────┘

subtractNanoseconds

導入バージョン: v20.1.0

日時、または文字列としてエンコードされた日時から、指定したナノ秒数を減算します。

構文

subtractNanoseconds(datetime, num)

引数

datetime — 指定したナノ秒数を減算する日時。DateTime または DateTime64 または String
num — 減算するナノ秒数。(U)Int* または Float*

戻り値

datetime から num ナノ秒を減算した結果を返します。 DateTime64

例

異なる日時型からナノ秒を減算する

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractNanoseconds(date_time, 1000) AS subtract_nanoseconds_with_date_time,
    subtractNanoseconds(date_time_string, 1000) AS subtract_nanoseconds_with_date_time_string

┌─subtract_nanoseconds_with_date_time─┬─subtract_nanoseconds_with_date_time_string─┐
│       2023-12-31 23:59:59.999999000 │              2023-12-31 23:59:59.999999000 │
└─────────────────────────────────────┴────────────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 nanosecond)

┌─minus(CAST('1998-06-16', 'DateTime'), toIntervalNanosecond(10))─┐
│                                   1998-06-15 23:59:59.999999990 │
└─────────────────────────────────────────────────────────────────┘

subtractQuarters

導入バージョン: v20.1.0

日付、日時、または文字列としてエンコードされた日付もしくは日時から、指定した数の四半期を減算します。

構文

subtractQuarters(datetime, num)

引数

datetime — 指定した数の四半期を減算する対象の日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 減算する四半期の数。(U)Int* または Float*

戻り値

datetime から num 四半期を減算した値。Date または Date32 または DateTime または DateTime64

例

異なる日付型で四半期を減算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractQuarters(date, 1) AS subtract_quarters_with_date,
    subtractQuarters(date_time, 1) AS subtract_quarters_with_date_time,
    subtractQuarters(date_time_string, 1) AS subtract_quarters_with_date_time_string

┌─subtract_quarters_with_date─┬─subtract_quarters_with_date_time─┬─subtract_quarters_with_date_time_string─┐
│                  2023-10-01 │              2023-10-01 00:00:00 │                 2023-10-01 00:00:00.000 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 quarter)

┌─minus(CAST('1998-06-16', 'Date'), toIntervalQuarter(10))─┐
│                                               1995-12-16 │
└──────────────────────────────────────────────────────────┘

subtractSeconds

導入バージョン: v1.1.0

指定した秒数を、日付、日時、または文字列として表現された日付もしくは日時から減算します。

構文

subtractSeconds(datetime, num)

引数

datetime — 指定した秒数を減算する対象の日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 減算する秒数。(U)Int* または Float*

戻り値

datetime から num 秒を減算した値を返します。DateTime または DateTime64(3)

例

異なる日付型から秒数を減算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractSeconds(date, 60) AS subtract_seconds_with_date,
    subtractSeconds(date_time, 60) AS subtract_seconds_with_date_time,
    subtractSeconds(date_time_string, 60) AS subtract_seconds_with_date_time_string

┌─subtract_seconds_with_date─┬─subtract_seconds_with_date_time─┬─subtract_seconds_with_date_time_string─┐
│        2023-12-31 23:59:00 │             2023-12-31 23:59:00 │                2023-12-31 23:59:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 second)

┌─minus(CAST('1998-06-16', 'Date'), toIntervalSecond(10))─┐
│                                     1998-06-15 23:59:50 │
└─────────────────────────────────────────────────────────┘

subtractTupleOfIntervals

導入バージョン: v22.11.0

日付または日時から、タプルを順に減算します。

構文

subtractTupleOfIntervals(datetime, intervals)

引数

datetime — ここからインターバルを減算する日付または日時。Date または Date32 または DateTime または DateTime64
intervals — datetime から減算するタプル。Tuple(Interval)

戻り値

intervals を減算した date を返します。Date または Date32 または DateTime または DateTime64

例

日付からタプルを減算する

WITH toDate('2018-01-01') AS date SELECT subtractTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 YEAR))

┌─subtractTupleOfIntervals(date, (toIntervalDay(1), toIntervalYear(1)))─┐
│                                                            2016-12-31 │
└───────────────────────────────────────────────────────────────────────┘

subtractWeeks

導入バージョン: v1.1.0

日付、日時、または文字列形式の日付もしくは日時から、指定した週数を減算します。

構文

subtractWeeks(datetime, num)

引数

datetime — 指定した週数を減算する基準となる日付または日時。 Date または Date32 または DateTime または DateTime64 または String
num — 減算する週数。 (U)Int* または Float*

戻り値

datetime から num 週を減算した値。 Date または Date32 または DateTime または DateTime64

例

さまざまな日付型から週を減算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractWeeks(date, 1) AS subtract_weeks_with_date,
    subtractWeeks(date_time, 1) AS subtract_weeks_with_date_time,
    subtractWeeks(date_time_string, 1) AS subtract_weeks_with_date_time_string

┌─subtract_weeks_with_date─┬─subtract_weeks_with_date_time─┬─subtract_weeks_with_date_time_string─┐
│               2023-12-25 │           2023-12-25 00:00:00 │              2023-12-25 00:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 week)

┌─minus(CAST('1998-06-16', 'Date'), toIntervalWeek(10))─┐
│                                            1998-04-07 │
└───────────────────────────────────────────────────────┘

subtractYears

導入バージョン: v1.1.0

日付、日時、または文字列としてエンコードされた日付もしくは日時から、指定した年数を減算します。

構文

subtractYears(datetime, num)

引数

datetime — 指定した年数を減算する日付または日時。Date または Date32 または DateTime または DateTime64 または String
num — 減算する年数。(U)Int* または Float*

戻り値

datetime から num 年を減算した値を返します。Date または Date32 または DateTime または DateTime64

例

異なる日付型から年を減算する

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractYears(date, 1) AS subtract_years_with_date,
    subtractYears(date_time, 1) AS subtract_years_with_date_time,
    subtractYears(date_time_string, 1) AS subtract_years_with_date_time_string

┌─subtract_years_with_date─┬─subtract_years_with_date_time─┬─subtract_years_with_date_time_string─┐
│               2023-01-01 │           2023-01-01 00:00:00 │              2023-01-01 00:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘

代替の INTERVAL 構文の使用

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 year)

┌─minus(CAST('1998-06-16', 'Date'), toIntervalYear(10))─┐
│                                            1988-06-16 │
└───────────────────────────────────────────────────────┘

timeDiff

導入バージョン: v23.4.0

2つの日付、または時刻値を含む2つの日付の差を秒単位で返します。差は enddate - startdate で計算されます。

この関数は dateDiff('second', startdate, enddate) と同等です。

時間差を他の単位 (時間、日、月など) で計算する場合は、代わりに dateDiff 関数を使用します。

構文

timeDiff(startdate, enddate)

引数

startdate — 最初の時刻値 (減数) 。Date または Date32 または DateTime または DateTime64
enddate — startdate を差し引く元の 2 番目の時刻値 (被減数) 。Date または Date32 または DateTime または DateTime64

戻り値

enddate と startdate の差を秒単位で返します。Int64

例

秒単位の時刻差を計算する

SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res

┌───res─┐
│ 90000 │
└───────┘

時間差を計算して時間単位に変換する

SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) / 3600 AS hours

┌─hours─┐
│    25 │
└───────┘

dateDiff の seconds 指定と同等

SELECT
    timeDiff(toDateTime('2021-12-29'), toDateTime('2022-01-01')) AS time_diff_result,
    dateDiff('second', toDateTime('2021-12-29'), toDateTime('2022-01-01')) AS date_diff_result

┌─time_diff_result─┬─date_diff_result─┐
│           259200 │           259200 │
└──────────────────┴──────────────────┘

timeSlot

導入バージョン: v1.1.0

時刻を30分単位の時間区間の開始時刻に丸めます。

構文

timeSlot(time[, time_zone])

引数

time — 30分間隔の開始時刻に丸める時刻。DateTime または Date32 または DateTime64
time_zone — 任意。タイムゾーンを表す String 型の定数値または式。String

戻り値

30分間隔の開始時刻に丸められた時刻を返します。DateTime

例

時刻を30分間隔の開始時刻に丸める

SELECT timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))

┌─timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))─┐
│                                2000-01-02 03:00:00 │
└────────────────────────────────────────────────────┘

timeSlots

導入バージョン: v1.1.0

StartTime から始まり Duration 秒間続く時間間隔に対して、この区間内の時点を秒単位で Size ごとに切り捨てた時点からなる配列を返します。Size は省略可能なパラメータで、デフォルト値は 1800 (30 分) です。

これは、たとえば対応するセッション内のページビューを検索する際に必要です。

DateTime64 の場合、返り値のスケールは StartTime のスケールと異なることがあります。指定されたすべての引数のうち、最も高いスケールが使用されます。

構文

timeSlots(StartTime, Duration[, Size])

引数

StartTime — 期間の開始時刻。DateTime または DateTime64
Duration — 期間の長さ (秒) 。UInt32 または DateTime64
Size — 任意。時間スロットのサイズ (秒) 。デフォルトは 1800 (30 分) です。UInt32 または DateTime64

戻り値

DateTime/DateTime64 の配列を返します (戻り値の型は StartTime の型に一致します) 。DateTime64 の場合、戻り値のスケールは StartTime のスケールと異なることがあり、指定されたすべての引数の中で最も高いスケールが使用されます。Array(DateTime) または Array(DateTime64)

例

期間の時間スロットを生成する

SELECT timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600));
SELECT timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299);
SELECT timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0))

┌─timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600))─┐
│ ['2012-01-01 12:00:00','2012-01-01 12:30:00']               │
└─────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299)─┐
│ ['1980-12-12 20:56:13','1980-12-12 21:01:12','1980-12-12 21:06:11']     │
└─────────────────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0))─┐
│ ['1980-12-12 20:56:13.0000','1980-12-12 21:01:12.0000','1980-12-12 21:06:11.0000']                        │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘

timestamp

導入バージョン: v23.9.0

最初の引数 expr を DateTime64(6) 型に変換します。 2 つ目の引数 expr_time が指定されている場合は、変換後の値に指定した時刻を加算します。

構文

timestamp(expr[, expr_time])

引数

expr — 日付または日時。String
expr_time — 任意。変換後の値に加算する時刻。String

戻り値

expr の変換後の値、または expr に時刻を加えた DateTime64(6) を返します

例

日付文字列を DateTime64(6) に変換

SELECT timestamp('2023-12-31') AS ts;

┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘

日付文字列に時刻を追加する

SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') AS ts;

┌─────────────────────────ts─┐
│ 2024-01-01 00:00:00.110000 │
└────────────────────────────┘

timezone

導入バージョン: v21.4.0

現在のセッションのタイムゾーン名を返すか、タイムゾーンのオフセットまたは名前を正規のタイムゾーン名に変換します。

構文

timezone()

別名: timeZone

引数

なし。

戻り値

String型の正規のタイムゾーン名を返します

例

使用例

SELECT timezone()

┌─timezone()───────┐
│ Europe/Amsterdam │
└──────────────────┘

timezoneOf

導入バージョン: v21.4.0

DateTime または DateTime64 の値に設定されたタイムゾーン名を返します。

構文

timezoneOf(datetime)

別名: timeZoneOf

引数

datetime — DateTime 型または DateTime64 型の値
timezone — 任意。datetime 値のタイムゾーンの変換先となるタイムゾーン名。String

戻り値

datetime のタイムゾーン名を返します。String

例

使用例

SELECT timezoneOf(now());

┌─timezoneOf(now())─┐
│ Etc/UTC           │
└───────────────────┘

timezoneOffset

導入バージョン: v21.6.0

UTC からのタイムゾーンオフセットを秒数で返します。この関数は、指定した日時における夏時間や過去のタイムゾーン変更を考慮します。

構文

timezoneOffset(datetime)

別名: timeZoneOffset

引数

datetime — タイムゾーンオフセットの取得対象となる DateTime 値。DateTime または DateTime64

戻り値

UTC からのオフセットを秒単位で返します。Int32

例

使用例

SELECT toDateTime('2021-04-21 10:20:30', 'America/New_York') AS Time,
toTypeName(Time) AS Type,
timezoneOffset(Time) AS Offset_in_seconds,
(Offset_in_seconds / 3600) AS Offset_in_hours;

┌────────────────Time─┬─Type─────────────────────────┬─Offset_in_seconds─┬─Offset_in_hours─┐
│ 2021-04-21 10:20:30 │ DateTime('America/New_York') │            -14400 │              -4 │
└─────────────────────┴──────────────────────────────┴───────────────────┴─────────────────┘

toDayOfMonth

導入バージョン: v1.1.0

Date または DateTime の日 (1〜31) を返します。

構文

toDayOfMonth(datetime)

別名: DAY, DAYOFMONTH

引数

datetime — 月の日を取得する対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定された日付/日時の月の日を返します。UInt8

例

使用例

SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))

┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│                                              21 │
└─────────────────────────────────────────────────┘

toDayOfWeek

導入バージョン: v1.1.0

Date または DateTime の値に対して、曜日を表す数値を返します。

toDayOfWeek() の 2 引数形式では、週の開始日を月曜日または日曜日のどちらにするか、また、戻り値の範囲を 0〜6 または 1〜7 のどちらにするかを指定できます。

モード	週の最初の日	範囲
0	月曜日	1-7: 月曜日 = 1, 火曜日 = 2, …, 日曜日 = 7
1	月曜日	0-6: 月曜日 = 0, 火曜日 = 1, …, 日曜日 = 6
2	日曜日	0-6: 日曜日 = 0, 月曜日 = 1, …, 土曜日 = 6
3	日曜日	1-7: 日曜日 = 1, 月曜日 = 2, …, 土曜日 = 7

構文

toDayOfWeek(datetime[, mode[, timezone]])

別名: DAYOFWEEK

引数

datetime — 曜日を取得する対象の日付または日時。Date または Date32 または DateTime または DateTime64
mode — 省略可能。週のモード (0～3) を指定する整数です。省略した場合のデフォルト値は 0 です。UInt8
timezone — 省略可能。変換に使用するタイムゾーンです。String

戻り値

指定された Date または DateTime に対応する曜日を返します。UInt8

例

使用例

-- 以下の日付は2023年4月21日（金曜日）です:
SELECT
    toDayOfWeek(toDateTime('2023-04-21')),
    toDayOfWeek(toDateTime('2023-04-21'), 1)

┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│                                     5 │                                        4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘

toDayOfYear

導入バージョン: v18.4.0

Date または DateTime の値に対応する、年内での通算日数 (1～366) を返します。

構文

toDayOfYear(datetime)

別名: DAYOFYEAR

引数

datetime — 年内通算日を取得する日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定した Date または DateTime の年内通算日を返します。UInt16

例

使用例

SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))

┌─toDayOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│                                            111 │
└────────────────────────────────────────────────┘

toDaysInMonth

導入バージョン: v26.3.0

Date または DateTime が属する月の日数を返します。

戻り値の範囲は 28 ～ 31 です。

構文

toDaysInMonth(datetime)

引数

datetime — 月の日数を取得する対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定された日付または日時が属する月の日数を返します。UInt8

例

使用例

SELECT toDaysInMonth(toDate('2023-02-01')), toDaysInMonth(toDate('2024-02-01')), toDaysInMonth(toDate('2023-01-01'))

┌─toDaysInMonth(toDate('2023-02-01'))─┬─toDaysInMonth(toDate('2024-02-01'))─┬─toDaysInMonth(toDate('2023-01-01'))─┐
│                                  28 │                                  29 │                                  31 │
└─────────────────────────────────────┴─────────────────────────────────────┴─────────────────────────────────────┘

toDaysSinceYearZero

導入バージョン: v23.9.0

指定した日付について、ISO 8601 で定義されたプロレプティック・グレゴリオ暦における 0000 年 1 月 1 日からの経過日数を返します。

この計算は、MySQL の TO_DAYS 関数と同じです。

構文

toDaysSinceYearZero(date[, time_zone])

別名: TO_DAYS

引数

date — 紀元 0 年からの経過日数を計算する対象の日付または日時。Date または Date32 または DateTime または DateTime64
time_zone — タイムゾーン。String

戻り値

日付 0000-01-01 から経過した日数を返します。UInt32

例

紀元 0 年からの経過日数を計算する

SELECT toDaysSinceYearZero(toDate('2023-09-08'))

┌─toDaysSinceYearZero(toDate('2023-09-08'))─┐
│                                    739136 │
└───────────────────────────────────────────┘

toHour

導入バージョン: v1.1.0

DateTime または DateTime64 の値から、時の部分 (0～23) を返します。

構文

toHour(datetime)

別名: HOUR

引数

datetime — 時を取得する日時。DateTime または DateTime64

戻り値

datetime の時 (0～23) を返します。UInt8

例

使用例

SELECT toHour(toDateTime('2023-04-21 10:20:30'))

┌─toHour(toDateTime('2023-04-21 10:20:30'))─┐
│                                        10 │
└───────────────────────────────────────────┘

toISOWeek

導入バージョン: v20.1.0

日付または日時の ISO 週番号を返します。

これは toWeek(date, 3) と等価な互換関数です。 ISO 週は月曜日に始まり、年の最初の週は 1 月 4 日を含む週です。 ISO 8601 では、週番号の範囲は 1 から 53 です。

年の初めまたは終わりに近い日付では、前年または翌年の週番号が返される場合があることに注意してください。たとえば、 2025 年 12 月 29 日は 2026 年 1 月 4 日を含む最初の週に当たるため、週番号 1 を返します。

構文

toISOWeek(datetime[, timezone])

引数

datetime — ISO 週番号を取得する対象の日付または日時。Date または DateTime または Date32 または DateTime64
timezone — 任意。タイムゾーン。String

戻り値

ISO 8601 に準拠した ISO 週番号を返します。返される値は 1 から 53 までです。UInt8

例

ISO 週番号を取得する

SELECT toDate('2016-12-27') AS date, toISOWeek(date) AS isoWeek

┌───────date─┬─isoWeek─┐
│ 2016-12-27 │      52 │
└────────────┴─────────┘

ISO週は別の年に属する場合があります

SELECT toDate('2025-12-29') AS date, toISOWeek(date) AS isoWeek, toYear(date) AS year

┌───────date─┬─isoWeek─┬─year─┐
│ 2025-12-29 │       1 │ 2025 │
└────────────┴─────────┴──────┘

toISOYear

導入バージョン: v18.4.0

日付または日時を ISO 年番号に変換します。

構文

toISOYear(datetime)

引数

datetime — 日付または日時の値。Date または Date32 または DateTime または DateTime64

戻り値

入力値を ISO年の番号に変換して返します。UInt16

例

日付の値から ISO年を取得する

SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2

┌─year1─┬─year2─┐
│  2024 │  2024 │
└───────┴───────┘

toLastDayOfMonth

導入バージョン: v1.1.0

日付または日時を、その月の末日に切り上げます。

構文

toLastDayOfMonth(value)

別名: LAST_DAY

引数

value — その月の末日に切り上げる対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定された日付または日時が属する月の末日の日付を返します。Date

例

その月の末日に切り上げる

SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))

┌─toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│                                          2023-04-30 │
└─────────────────────────────────────────────────────┘

toLastDayOfWeek

導入バージョン: v23.5.0

日付または日時を、最も近い土曜日または日曜日まで切り上げます。

構文

toLastDayOfWeek(datetime[, mode[, timezone]])

引数

datetime — 変換する日付または日時。Date または DateTime または Date32 または DateTime64
mode — toWeek() 関数で説明されているとおり、週の開始日を決定します。デフォルトは 0 です。UInt8
timezone — 任意。変換に使用するタイムゾーンです。指定しない場合は、server のタイムゾーンが使用されます。String

戻り値

mode に応じて、指定した日付と同日またはそれ以降で最も近い土曜日または日曜日の日付を返します。Date または Date32

例

最も近い土曜日または日曜日に切り上げる

SELECT
    toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
    toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
    toLastDayOfWeek(toDate('2023-04-23')), /* a Sunday */
    toLastDayOfWeek(toDate('2023-04-23'), 1) /* a Sunday */
FORMAT Vertical

Row 1:
──────
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')):    2023-04-22
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-23
toLastDayOfWeek(toDate('2023-04-23')):                 2023-04-29
toLastDayOfWeek(toDate('2023-04-23'), 1):              2023-04-23

toMicrosecond

導入バージョン: v25.7.0

DateTime64 値のマイクロ秒部分 (0〜999999) を返します。

構文

toMicrosecond(datetime)

別名: MICROSECOND

引数

datetime — マイクロ秒を取得する対象の日時。DateTime64

戻り値

datetime の秒部分に含まれるマイクロ秒 (0 - 999999) を返します。UInt32

例

使用例

SELECT toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6));

┌─toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6))─┐
│                                                       456789 │
└──────────────────────────────────────────────────────────────┘

toMillisecond

導入バージョン: v24.2.0

DateTime または DateTime64 の値のミリ秒部分 (0～999) を返します。

構文

toMillisecond(datetime)

別名: MILLISECOND

引数

datetime — ミリ秒を取得する対象の日時。DateTime または DateTime64

戻り値

datetime の分におけるミリ秒 (0 - 59) を返します。UInt16

例

使用例

SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));

┌─toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│                                                       456 │
└───────────────────────────────────────────────────────────┘

toMinute

導入バージョン: v1.1.0

Date または DateTime の値から分の部分 (0～59) を返します。

構文

toMinute(datetime)

別名: MINUTE

引数

datetime — 分を取得する日時。DateTime または DateTime64

戻り値

datetime の分 (0 - 59) を返します。UInt8

例

使用例

SELECT toMinute(toDateTime('2023-04-21 10:20:30'))

┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│                                          20 │
└─────────────────────────────────────────────┘

toModifiedJulianDay

導入バージョン: v21.1.0

テキスト形式 YYYY-MM-DD のプロレプティック・グレゴリオ暦の日付を、Int32 の修正ユリウス日の数値に変換します。この関数は、0000-01-01 から 9999-12-31 までの日付をサポートします。引数を日付として解析できない場合、または日付が無効な場合は例外をスローします。

構文

toModifiedJulianDay(date)

引数

date — 文字列形式の日付。String または FixedString

戻り値

修正ユリウス日番号を返します。Int32

例

日付を修正ユリウス日番号に変換

SELECT toModifiedJulianDay('2020-01-01')

┌─toModifiedJulianDay('2020-01-01')─┐
│                             58849 │
└───────────────────────────────────┘

toModifiedJulianDayOrNull

導入バージョン: v21.1.0

toModifiedJulianDay() と同様ですが、例外を発生させる代わりに NULL を返します。

構文

toModifiedJulianDayOrNull(date)

引数

date — テキスト形式の日付。String または FixedString

戻り値

有効な date の修正ユリウス日番号を返し、それ以外の場合は NULL を返します。Nullable(Int32)

例

NULL を処理しながら日付を修正ユリウス日に変換

SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- invalid date, returns NULL

┌─toModifiedJulianDayOrNull('2020-01-01')─┐
│                                   58849 │
└─────────────────────────────────────────┘
┌─toModifiedJulianDayOrNull('0000-00-00')─┐
│                                    ᴺᵁᴸᴸ │
└─────────────────────────────────────────┘

toMonday

導入バージョン: v1.1.0

日付または日時を、同じ週の月曜日に切り下げます。日付を返します。

構文

toMonday(value)

引数

value — その週の月曜日に切り下げる対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定された日付または日時が属する週の月曜日の日付を返します。Date

例

その週の月曜日に切り下げる

SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- A Friday
toMonday(toDate('2023-04-24'));              -- Already a Monday

┌─toMonday(toDateTime('2023-04-21 10:20:30'))─┬─toMonday(toDate('2023-04-24'))─┐
│                                  2023-04-17 │                     2023-04-24 │
└─────────────────────────────────────────────┴────────────────────────────────┘

toMonth

導入バージョン: v1.1.0

Date または DateTime の値の月の部分 (1～12) を返します。

構文

toMonth(datetime)

別名: MONTH

引数

datetime — 月を取得する対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定した日付または日時の月を返します。UInt8

例

使用例

SELECT toMonth(toDateTime('2023-04-21 10:20:30'))

┌─toMonth(toDateTime('2023-04-21 10:20:30'))─┐
│                                          4 │
└────────────────────────────────────────────┘

toMonthNumSinceEpoch

導入バージョン: v25.3.0

1970年からの経過月数を返します

構文

toMonthNumSinceEpoch(date)

引数

date — 日付または日時。Date、DateTime、または DateTime64

戻り値

正の整数

例

SELECT toMonthNumSinceEpoch(toDate('2024-10-01'))

toNanosecond

導入バージョン: v25.7.0

DateTime64 値のナノ秒部分 (0-999999999) を返します。

構文

toNanosecond(datetime)

別名: NANOSECOND

引数

datetime — ナノ秒を取得する対象の日時。DateTime64

戻り値

datetime の秒部分に含まれるナノ秒 (0 - 999999999) を返します。UInt32

例

使用例

SELECT toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9));

┌─toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9))─┐
│                                                      123456789 │
└────────────────────────────────────────────────────────────────┘

toQuarter

導入バージョン: v1.1.0

指定された Date または DateTime の値に対応する年の四半期 (1～4) を返します。

構文

toQuarter(datetime)

別名: QUARTER

引数

datetime — 年の四半期を取得する対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定した日付または日時に対応する年の四半期を返します。UInt8

例

使用例

SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))

┌─toQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│                                            2 │
└──────────────────────────────────────────────┘

toRelativeDayNum

導入バージョン: v1.1.0

日付または日時を、過去のある固定時点からの経過日数に変換します。正確な起点は実装の詳細に属するため、この関数を単独で使用することは想定されていません。この関数の主な目的は、2 つの日付または日時の差 (日数) を計算することです。たとえば、toRelativeDayNum(dt1) - toRelativeDayNum(dt2) のように使用します。

構文

toRelativeDayNum(date)

引数

date — 日付または日時。Date または DateTime または DateTime64

戻り値

過去のある固定された基準時点からの日数を返します。UInt32

例

相対的な日数を取得

SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))

┌─minus(toRelativeDayNum(toDate('2023-04-01')), toRelativeDayNum(toDate('2023-01-01')))─┐
│                                                                                    90 │
└───────────────────────────────────────────────────────────────────────────────────────┘

toRelativeHourNum

導入バージョン: v1.1.0

日付または日時を、過去のある固定時点からの経過時間数に変換します。正確な基準時点は実装の詳細に依存するため、この関数を単独で使用することは想定されていません。この関数の主な目的は、2 つの日付または日時の時間差を計算することです。たとえば、toRelativeHourNum(dt1) - toRelativeHourNum(dt2) のように使用します。

構文

toRelativeHourNum(date)

引数

date — 日付または日時。Date または DateTime または DateTime64

戻り値

過去の固定された基準時点からの経過時間数を返します。UInt32

例

相対時間数を取得する

SELECT toRelativeHourNum(toDateTime('2023-01-01 12:00:00')) - toRelativeHourNum(toDateTime('2023-01-01 00:00:00')) AS hours_difference

┌─hours_difference─┐
│               12 │
└──────────────────┘

toRelativeMinuteNum

導入バージョン: v1.1.0

日付または日時を、過去のある固定時点からの経過分数に変換します。正確にどの時点を指すかは実装の詳細であるため、この関数を単独で使用することは想定されていません。この関数の主な用途は、2 つの日付または日時の差を分単位で計算することです。たとえば、toRelativeMinuteNum(dt1) - toRelativeMinuteNum(dt2) のように使用します。

構文

toRelativeMinuteNum(date)

引数

date — 日付または日時。Date または DateTime または DateTime64

戻り値

過去の固定された基準時点からの分単位の数を返します。UInt32

例

相対的な分番号を取得

SELECT toRelativeMinuteNum(toDateTime('2023-01-01 00:30:00')) - toRelativeMinuteNum(toDateTime('2023-01-01 00:00:00')) AS minutes_difference

┌─minutes_difference─┐
│                 30 │
└────────────────────┘

toRelativeMonthNum

導入バージョン: v1.1.0

日付または日時を、過去のある固定時点からの経過月数に変換します。正確な起点は実装の詳細に依存するため、この関数を単独で使用することは想定されていません。この関数の主な目的は、2つの日付または日時の差を月単位で計算することです。たとえば、toRelativeMonthNum(dt1) - toRelativeMonthNum(dt2) のように使用します。

構文

toRelativeMonthNum(date)

引数

date — 日付または日時。Date または DateTime または DateTime64

戻り値

過去のある固定の基準時点からの経過月数を返します。UInt32

例

相対月番号を取得する

SELECT toRelativeMonthNum(toDate('2023-04-01')) - toRelativeMonthNum(toDate('2023-01-01')) AS months_difference

┌─months_difference─┐
│                 3 │
└───────────────────┘

toRelativeQuarterNum

導入バージョン: v1.1.0

日付または日時を、過去のある固定時点から何四半期経過したかを表す数値に変換します。その正確な時点は実装の詳細であるため、この関数を単体で使用することは想定されていません。この関数の主な目的は、2 つの日付または日時の四半期の差を計算することです。たとえば、toRelativeQuarterNum(dt1) - toRelativeQuarterNum(dt2) のように使用します。

構文

toRelativeQuarterNum(date)

引数

date — 日付または日時。Date または DateTime または DateTime64

戻り値

過去のある固定された基準時点からの四半期数を返します。UInt32

例

相対四半期番号を取得

SELECT toRelativeQuarterNum(toDate('2023-04-01')) - toRelativeQuarterNum(toDate('2023-01-01')) AS quarters_difference

┌─quarters_difference─┐
│                   1 │
└─────────────────────┘

toRelativeSecondNum

導入バージョン: v1.1.0

日付または日時を、過去のある固定時点からの経過秒数に変換します。その正確な起点は実装の詳細であるため、この関数を単独で使用することは想定されていません。この関数の主な用途は、2 つの日付または日時の差を秒単位で計算することです。たとえば、toRelativeSecondNum(dt1) - toRelativeSecondNum(dt2) のように使用します。

構文

toRelativeSecondNum(date)

引数

date — 日付または日時。Date または DateTime または DateTime64

戻り値

過去のある固定された基準時点からの秒数を返します。UInt32

例

相対秒数を取得

SELECT toRelativeSecondNum(toDateTime('2023-01-01 00:01:00')) - toRelativeSecondNum(toDateTime('2023-01-01 00:00:00')) AS seconds_difference

┌─seconds_difference─┐
│                 60 │
└────────────────────┘

toRelativeWeekNum

導入バージョン: v1.1.0

日付または日時を、過去のある固定時点からの経過週数に変換します。正確な基準時点は実装の詳細であるため、この関数を単独で使用することは想定されていません。この関数の主な用途は、2 つの日付または日時の週数の差を計算することです。たとえば、toRelativeWeekNum(dt1) - toRelativeWeekNum(dt2) のように使用します。

構文

toRelativeWeekNum(date)

引数

date — 日付または日時。Date または DateTime または DateTime64

戻り値

過去のある固定された基準時点からの週数を返します。UInt32

例

相対週番号を取得する

SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference

┌─weeks_difference─┐
│                1 │
└──────────────────┘

toRelativeYearNum

導入バージョン: v1.1.0

日付または日時を、過去のある固定時点からの経過年数に変換します。その正確な時点は実装の詳細であるため、この関数を単独で使用することは想定されていません。この関数の主な目的は、2 つの日付または日時の年数の差を計算することです。たとえば、toRelativeYearNum(dt1) - toRelativeYearNum(dt2) のように使用します。

構文

toRelativeYearNum(date)

引数

date — 日付または日時。Date または DateTime または DateTime64

戻り値

過去のある固定された基準時点からの年数を返します。UInt16

例

相対年番号を取得

SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)

┌─minus(toRelativeYearNum(CAST('2010-10-01', 'DateTime')), toRelativeYearNum(CAST('2000-01-01', 'DateTime')))─┐
│                                                                                                          10 │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

toSecond

導入バージョン: v1.1.0

DateTime または DateTime64 の値から秒の部分 (0～59) を返します。

構文

toSecond(datetime)

別名: SECOND

引数

datetime — 秒を取得する日時。DateTime または DateTime64

戻り値

datetime の分の秒 (0 - 59) を返します。UInt8

例

使用例

SELECT toSecond(toDateTime('2023-04-21 10:20:30'))

┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│                                          30 │
└─────────────────────────────────────────────┘

toStartOfDay

導入バージョン: v1.1.0

日時をその日の開始時刻に切り下げます。

構文

toStartOfDay(datetime)

引数

datetime — 丸める対象の日付または日時。Date または DateTime

戻り値

その日の開始時刻に切り下げられた日時を返します。DateTime または DateTime64

例

その日の開始時刻に切り下げる

SELECT toStartOfDay(toDateTime('2023-04-21 10:20:30'))

┌─toStartOfDay(toDateTime('2023-04-21 10:20:30'))─┐
│                             2023-04-21 00:00:00 │
└─────────────────────────────────────────────────┘

toStartOfFifteenMinutes

導入バージョン: v1.1.0

日時を15分間隔の開始時点に切り下げます。

構文

toStartOfFifteenMinutes(datetime)

引数

datetime — 丸める対象の日付または日時。DateTime または DateTime64

戻り値

最も近い15分間隔の開始時刻に丸めた日時を返します。DateTime または DateTime64

例

SELECT
    toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')),
    toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')),
    toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical

Row 1:
──────
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:15:00

toStartOfFiveMinutes

導入バージョン: v22.6.0

日時を直前の5分間隔の開始時点に切り下げます。

構文

toStartOfFiveMinutes(datetime)

別名: toStartOfFiveMinute

引数

datetime — 丸める対象の日時。DateTime または DateTime64

戻り値

日時を直近の5分間隔の開始時刻に丸めた値を返します。DateTime または DateTime64

例

SELECT
    toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')),
    toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')),
    toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical

Row 1:
──────
toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00

toStartOfHour

導入バージョン: v1.1.0

日時をその時間の開始時刻に切り下げます。

構文

toStartOfHour(datetime)

引数

datetime — 丸める対象の日時。DateTime または DateTime64

戻り値

その時間の開始時刻まで切り下げた日時を返します。DateTime または DateTime64

例

その時間の開始時刻まで切り下げる

SELECT
    toStartOfHour(toDateTime('2023-04-21 10:20:30'));

┌─toStartOfHour(toDateTime('2023-04-21 10:20:30'))─┐
│                              2023-04-21 10:00:00 │
└──────────────────────────────────────────────────┘

toStartOfISOYear

導入バージョン: v1.1.0

日付または日時を ISO 年の最初の日まで切り下げます。これは通常の暦年とは異なる場合があります。ISO 週日付を参照してください。

構文

toStartOfISOYear(value)

引数

value — ISO 年の初日に切り下げる日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定した日付または日時に対応する ISO 年の初日を返します。Date

例

ISO 年の初日に切り下げる

SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))

┌─toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))─┐
│                                          2023-01-02 │
└─────────────────────────────────────────────────────┘

toStartOfInterval

導入バージョン: v20.1.0

この関数は、toStartOfInterval(date_or_date_with_time, INTERVAL x unit [, time_zone]) 構文によって、他の toStartOf*() 関数を一般化した関数です。

たとえば、

toStartOfInterval(t, INTERVAL 1 YEAR) は toStartOfYear(t) と同じ結果を返します。
toStartOfInterval(t, INTERVAL 1 MONTH) は toStartOfMonth(t) と同じ結果を返します。
toStartOfInterval(t, INTERVAL 1 DAY) は toStartOfDay(t) と同じ結果を返します。
toStartOfInterval(t, INTERVAL 15 MINUTE) は toStartOfFifteenMinutes(t) と同じ結果を返します。

計算は、特定の時点を基準に行われます。

インターバル	開始点
YEAR	0年
QUARTER	1900年第1四半期
MONTH	1900年1月
WEEK	1970年の第1週 (01-05)
DAY	1970-01-01
HOUR	(*)
MINUTE	1970-01-01 00:00:00
SECOND	1970-01-01 00:00:00
MILLISECOND	1970-01-01 00:00:00
MICROSECOND	1970-01-01 00:00:00
NANOSECOND	1970-01-01 00:00:00
(*) 時間単位のインターバルは特殊で、計算は常に当日の 00:00:00 (深夜) を基準に行われます。そのため、
1 から 23 までの時間の値だけが有効です。

unit に WEEK を指定した場合、toStartOfInterval は週の開始日を月曜日と見なします。この動作は、週の開始日がデフォルトで日曜日である関数 toStartOfWeek とは異なる点に注意してください。

2 番目のオーバーロードは、TimescaleDB の time_bucket() 関数、または PostgreSQL の date_bin() 関数をエミュレートします。

構文

toStartOfInterval(value, INTERVAL x unit[, time_zone])
toStartOfInterval(value, INTERVAL x unit[, origin[, time_zone]])

別名: date_bin, time_bucket

引数

value — 切り下げる日付または日時の値。Date または DateTime または DateTime64
x — インターバルの長さを表す数値。- unit — インターバルの単位: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND, MILLISECOND, MICROSECOND, NANOSECOND. - time_zone — 任意。文字列で指定するタイムゾーン名。- origin — 任意。計算の始点 (2 番目のオーバーロードのみ)。

戻り値

入力値を含むインターバルの開始時点を返します。DateTime

例

基本的なインターバルの丸め

SELECT toStartOfInterval(toDateTime('2023-01-15 14:30:00'), INTERVAL 1 MONTH)

┌─toStartOfInterval(toDateTime('2023-01-15 14:30:00'), toIntervalMonth(1))─┐
│                                                               2023-01-01 │
└──────────────────────────────────────────────────────────────────────────┘

始点を使用する

SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'))

┌─toStartOfInterval(toDateTime('2023-01-01 14:45:00'), toIntervalMinute(1), toDateTime('2023-01-01 14:35:30'))─┐
│                                                                                          2023-01-01 14:44:30 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

toStartOfMicrosecond

導入バージョン: v22.6.0

日時をマイクロ秒の開始時点に切り下げます。

構文

toStartOfMicrosecond(datetime[, timezone])

引数

datetime — 日付と時刻。DateTime64
timezone — 省略可能。戻り値のタイムゾーンです。指定しない場合、関数は value パラメータのタイムゾーンを使用します。String

戻り値

マイクロ秒未満を含む入力値。DateTime64

例

タイムゾーンを指定しないクエリ

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64);

┌────toStartOfMicrosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999000 │
└───────────────────────────────┘

タイムゾーンを指定したクエリ

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');

┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
│               2020-01-01 13:20:30.999999000 │
└─────────────────────────────────────────────┘

toStartOfMillisecond

導入バージョン: v22.6.0

日時をミリ秒の先頭に切り下げます。

構文

toStartOfMillisecond(datetime[, timezone])

引数

datetime — 日付と時刻。DateTime64
timezone — 省略可能。戻り値のタイムゾーンです。指定しない場合、関数は value パラメーターのタイムゾーンを使用します。String

戻り値

ミリ秒未満の精度を含む入力値。DateTime64

例

タイムゾーンを指定しないクエリ

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64);

┌────toStartOfMillisecond(dt64)─┐
│ 2020-01-01 10:20:30.999000000 │
└───────────────────────────────┘

タイムゾーンを指定したクエリ

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64, 'Asia/Istanbul');

┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
│               2020-01-01 13:20:30.999000000 │
└─────────────────────────────────────────────┘

toStartOfMinute

導入バージョン: v1.1.0

日時をその分の先頭に切り捨てます。

構文

toStartOfMinute(datetime)

引数

datetime — 丸める日時。DateTime または DateTime64

戻り値

日時を分の先頭に切り下げて返します。DateTime または DateTime64

例

分の先頭に切り下げる

SELECT
    toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
    toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical

Row 1:
──────
toStartOfMinute(toDateTime('2023-04-21 10:20:30')):           2023-04-21 10:20:00
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8)): 2023-04-21 10:20:00

toStartOfMonth

導入バージョン: v1.1.0

日付または日時をその月の初日に切り下げます。

構文

toStartOfMonth(value)

引数

value — 月初に切り下げる対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定した日付または日時の月初を返します。Date

例

月初に切り下げる

SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))

┌─toStartOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│                                        2023-04-01 │
└───────────────────────────────────────────────────┘

toStartOfNanosecond

導入バージョン: v22.6.0

日時をナノ秒単位の先頭に切り下げます。

構文

toStartOfNanosecond(datetime[, timezone])

引数

datetime — 日付と時刻。DateTime64
timezone — 省略可。戻り値のタイムゾーン。指定しない場合、関数は value 引数のタイムゾーンを使用します。String

戻り値

ナノ秒を含む入力値。DateTime64

例

タイムゾーンを指定しないクエリ

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64);

┌─────toStartOfNanosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999999 │
└───────────────────────────────┘

タイムゾーンを指定したクエリ

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');

┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
│              2020-01-01 13:20:30.999999999 │
└────────────────────────────────────────────┘

toStartOfQuarter

導入バージョン: v1.1.0

日付または日時を、その四半期の初日に切り下げます。四半期の初日は、1月1日、4月1日、7月1日、または10月1日です。

構文

toStartOfQuarter(value)

引数

value — 四半期の初日に切り下げる対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定された日付または日時に対応する四半期の初日を返します。Date

例

四半期の初日に切り下げる

SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))

┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│                                          2023-04-01 │
└─────────────────────────────────────────────────────┘

toStartOfSecond

導入バージョン: v20.5.0

日時を秒の開始時刻に切り捨てます。

構文

toStartOfSecond(datetime[, timezone])

引数

datetime — 小数秒を切り捨てる日時。DateTime64
timezone — 省略可能。戻り値に使用するタイムゾーンです。指定しない場合、関数は value パラメータのタイムゾーンを使用します。String

戻り値

小数秒を除いた入力値を返します。DateTime64

例

タイムゾーンを指定しないクエリ

WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64);

┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└─────────────────────────┘

タイムゾーンを指定したクエリ

WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64, 'Asia/Istanbul');

┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
│                2020-01-01 13:20:30.000 │
└────────────────────────────────────────┘

toStartOfTenMinutes

導入バージョン: v20.1.0

日時を、その時刻を含む10分間隔の開始時刻に切り下げます。

構文

toStartOfTenMinutes(datetime)

引数

datetime — 日時。DateTime または DateTime64

戻り値

最も近い10分間隔の開始時刻に丸めた日時を返します。DateTime または DateTime64

例

SELECT
    toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')),
    toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')),
    toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical

Row 1:
──────
toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:10:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00

toStartOfWeek

導入バージョン: v20.1.0

日付または日時を、直前の日曜日または月曜日に切り下げます。

構文

toStartOfWeek(datetime[, mode[, timezone]])

引数

datetime — 変換する日付または日時。Date または DateTime または Date32 または DateTime64
mode — toWeek() 関数で説明されているとおり、週の開始日を決定します。デフォルトは 0 です。UInt8
timezone — 変換に使用するタイムゾーン。指定しない場合は、サーバーのタイムゾーンが使用されます。String

戻り値

mode に応じて、指定した日付当日またはそれ以前の直近の日曜日または月曜日の日付を返します。Date または Date32

例

直近の日曜日または月曜日に切り下げる

SELECT
        toStartOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
        toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
        toStartOfWeek(toDate('2023-04-24')), /* a Monday */
        toStartOfWeek(toDate('2023-04-24'), 1) /* a Monday */
    FORMAT Vertical

Row 1:
──────
toStartOfWeek(toDateTime('2023-04-21 10:20:30')):    2023-04-16
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-17
toStartOfWeek(toDate('2023-04-24')):                 2023-04-23
toStartOfWeek(toDate('2023-04-24'), 1):              2023-04-24

toStartOfYear

導入バージョン: v1.1.0

日付または日時を、その年の最初の日に切り下げます。結果は Date オブジェクトとして返されます。

構文

toStartOfYear(value)

引数

value — 切り下げる対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定した日付/時刻が属する年の最初の日を返します。Date

例

年の最初の日に切り下げる

SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))

┌─toStartOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│                                       2023-01-01 │
└──────────────────────────────────────────────────┘

toTimeWithFixedDate

導入バージョン: v25.5.0

日時から時刻部分を抽出します。返される結果は、現在は 1970-01-02 という固定時点からのオフセットですが、正確な時点は実装の詳細であり、将来変更される可能性があります。

したがって、toTimeWithFixedDate を単独で使用すべきではありません。この関数の主な目的は、2つの日時の時刻差を計算することです。例: toTimeWithFixedDate(dt1) - toTimeWithFixedDate(dt2)。

これは従来の toTime 関数であり、値を Time データ型に変換する toTime が toTime という名前を使用するようになったため、v25.5 でリネームされました。設定 use_legacy_to_time が有効な場合は、旧名称の toTime でも引き続き使用できます (v26.7 以降のデフォルトは 0 ですが、v25.6 から v26.6 までは 1 がデフォルトでした) 。

datetime 引数に秒未満の部分が含まれる場合、それらは削除され、秒精度の DateTime 値が返されます。

構文

toTimeWithFixedDate(datetime[, timezone])

引数

datetime — 時刻に変換する日時。DateTime または DateTime64
timezone — 省略可能。戻り値のタイムゾーン。String

戻り値

日時の時刻部分を、固定時点 (現在は 1970-01-02) からのオフセットとして返します。DateTime

例

2 つの日付間の時差を計算する

SELECT toTimeWithFixedDate('2025-06-15 12:00:00'::DateTime) - toTimeWithFixedDate('2024-05-10 11:00:00'::DateTime) AS result, toTypeName(result)

┌─result─┬─toTypeName(result)─┐
│   3600 │ Int32              │
└────────┴────────────────────┘

秒未満の部分は切り捨てられます

SELECT toTimeWithFixedDate(toDateTime64('1970-12-10 01:20:30.3000', 3)) AS result, toTypeName(result)

┌──────────────result─┬─toTypeName(result)─┐
│ 1970-01-02 01:20:30 │ DateTime           │
└─────────────────────┴────────────────────┘

legacy 名で呼び出した場合も同じ関数

SET use_legacy_to_time = 1;
SELECT toTime(toDateTime64('1970-12-10 01:20:30.3000', 3)) AS result, toTypeName(result)

┌──────────────result─┬─toTypeName(result)─┐
│ 1970-01-02 01:20:30 │ DateTime           │
└─────────────────────┴────────────────────┘

toTimezone

導入バージョン: v1.1.0

DateTime または DateTime64 を、指定したタイムゾーンに変換します。データの内部値 (Unix 秒数の数値) は変わりません。変わるのは、値のタイムゾーン属性と値の文字列表現だけです。

構文

toTimezone(datetime, timezone)

別名: toTimeZone

引数

date — 変換する値。DateTime または DateTime64
timezone — 変換先のタイムゾーン名。String

戻り値

入力と同じタイムスタンプを、指定したタイムゾーンの DateTime または DateTime64 として返します

例

使用例

SELECT toDateTime('2019-01-01 00:00:00', 'UTC') AS time_utc,
toTypeName(time_utc) AS type_utc,
toInt32(time_utc) AS int32utc,
toTimezone(time_utc, 'Asia/Yekaterinburg') AS time_yekat,
toTypeName(time_yekat) AS type_yekat,
toInt32(time_yekat) AS int32yekat,
toTimezone(time_utc, 'US/Samoa') AS time_samoa,
toTypeName(time_samoa) AS type_samoa,
toInt32(time_samoa) AS int32samoa
FORMAT Vertical;

行 1:
──────
time_utc:   2019-01-01 00:00:00
type_utc:   DateTime('UTC')
int32utc:   1546300800
time_yekat: 2019-01-01 05:00:00
type_yekat: DateTime('Asia/Yekaterinburg')
int32yekat: 1546300800
time_samoa: 2018-12-31 13:00:00
type_samoa: DateTime('US/Samoa')
int32samoa: 1546300800

toUTCTimestamp

導入バージョン: v23.8.0

日付または日時の値を、あるタイムゾーンから UTC タイムゾーンのタイムスタンプに変換します。この関数は主に、Apache Spark や同様のフレームワークとの互換性を確保するために用意されています。

構文

toUTCTimestamp(datetime, time_zone)

別名: to_utc_timestamp

引数

datetime — 日付型または日時型の定数値、あるいは式。DateTime または DateTime64
time_zone — タイムゾーンを表す String 型の定数値、あるいは式。String

戻り値

UTC タイムゾーンの日付または日時を返します。DateTime または DateTime64

例

タイムゾーンを UTC に変換する

SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')

┌─toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')─┐
│                                       2023-03-15 16:00:00 │
└───────────────────────────────────────────────────────────┘

toUnixTimestamp

導入バージョン: v1.1.0

String、Date、または DateTime を、UInt32 の Unix timestamp (1970-01-01 00:00:00 UTC からの経過秒数) に変換します。

構文

toUnixTimestamp(date[, timezone])

引数

date — 変換する値。Date または Date32 または DateTime または DateTime64 または String
timezone — 省略可能。変換に使用するタイムゾーン。指定しない場合は、サーバーのタイムゾーンが使用されます。String

戻り値

Unixタイムスタンプを返します。UInt32

例

使用例

SELECT
'2017-11-05 08:07:47' AS dt_str,
toUnixTimestamp(dt_str) AS from_str,
toUnixTimestamp(dt_str, 'Asia/Tokyo') AS from_str_tokyo,
toUnixTimestamp(toDateTime(dt_str)) AS from_datetime,
toUnixTimestamp(toDateTime64(dt_str, 0)) AS from_datetime64,
toUnixTimestamp(toDate(dt_str)) AS from_date,
toUnixTimestamp(toDate32(dt_str)) AS from_date32
FORMAT Vertical;

行 1:
──────
dt_str:          2017-11-05 08:07:47
from_str:        1509869267
from_str_tokyo:  1509836867
from_datetime:   1509869267
from_datetime64: 1509869267
from_date:       1509840000
from_date32:     1509840000

toWeek

導入バージョン: v20.1.0

この関数は、date または datetime の週番号を返します。toWeek() の 2 引数形式では、週の開始日を日曜日または月曜日のどちらにするかと、返り値の範囲を 0〜53 とするか 1〜53 とするかを指定できます。

toISOWeek() は、toWeek(date,3) と等価な互換関数です。

次の表は、mode 引数の動作を示しています。

Mode	First day of week	Range	Week 1 is the first week …
0	日曜日	0-53	その年の日曜日を含む最初の週
1	月曜日	0-53	その年に 4 日以上含まれる最初の週
2	日曜日	1-53	その年の日曜日を含む最初の週
3	月曜日	1-53	その年に 4 日以上含まれる最初の週
4	日曜日	0-53	その年に 4 日以上含まれる最初の週
5	月曜日	0-53	その年の月曜日を含む最初の週
6	日曜日	1-53	その年に 4 日以上含まれる最初の週
7	月曜日	1-53	その年の月曜日を含む最初の週
8	日曜日	1-53	1 月 1 日を含む
9	月曜日	1-53	1 月 1 日を含む

意味が "その年に 4 日以上含まれる" である mode 値では、週番号は ISO 8601:1988 に従って付けられます。

1 月 1 日を含む週が新年に 4 日以上含まれている場合、その週は第 1 週です。
それ以外の場合、その週は前年の最後の週となり、次の週が第 1 週です。

意味が "1 月 1 日を含む" である mode 値では、1 月 1 日を含む週が第 1 週です。その週に新年の日数が何日含まれているかは関係なく、たとえ 1 日しか含まれていなくても同様です。つまり、12 月の最後の週に翌年の 1 月 1 日が含まれている場合、それは翌年の第 1 週になります。

最初の引数は、parseDateTime64BestEffort でサポートされる形式の String として指定することもできます。文字列引数のサポートは、特定のサードパーティーツールが想定する MySQL との互換性のためにのみ存在します。文字列引数のサポートは、将来的に新しい MySQL 互換設定に依存するようになる可能性があり、また一般に文字列のパースは低速であるため、使用しないことを推奨します。

構文

toWeek(datetime[, mode[, time_zone]])

別名: week

引数

datetime — 週番号の取得元となる日付または日時。 Date または DateTime
mode — オプション。0 から 9 のモードで、週の開始曜日と週番号の範囲を指定します。デフォルトは 0 です。 - time_zone — オプション。タイムゾーン。 String

戻り値

指定したモードに応じた週番号を返します。 UInt32

例

異なるモードで週番号を取得する

SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9

┌───────date─┬─week0─┬─week1─┬─week9─┐
│ 2016-12-27 │    52 │    52 │     1 │
└────────────┴───────┴───────┴───────┘

toYYYYMM

導入バージョン: v1.1.0

日付または日時を、年と月の数値 (YYYY * 100 + MM) を含む UInt32 型の値に変換します。任意の2番目の引数としてタイムゾーンを指定できます。指定する場合、タイムゾーンは文字列定数である必要があります。

この関数は、関数 YYYYMMDDToDate() の逆です。

構文

toYYYYMM(datetime[, timezone])

引数

datetime — 変換する日付または日時。Date または Date32 または DateTime または DateTime64
timezone — 任意。変換に使用するタイムゾーン。指定する場合、タイムゾーンは文字列定数である必要があります。String

戻り値

年と月を表す数値 (YYYY * 100 + MM) を含む UInt32 を返します。

例

現在の日付を YYYYMM 形式に変換する

SELECT toYYYYMM(now(), 'US/Eastern')

┌─toYYYYMM(now(), 'US/Eastern')─┐
│                        202608 │
└───────────────────────────────┘

toYYYYMMDD

導入バージョン: v1.1.0

日付または日時を、年・月・日を表す UInt32 の数値 (YYYY * 10000 + MM * 100 + DD) に変換します。省略可能な第 2 引数としてタイムゾーンを指定できます。指定する場合、タイムゾーンは文字列定数である必要があります。

構文

toYYYYMMDD(datetime[, timezone])

引数

datetime — 変換対象の日付または日時。Date または Date32 または DateTime または DateTime64
timezone — 任意。変換に使用するタイムゾーンです。指定する場合、タイムゾーンは文字列定数である必要があります。String

戻り値

年・月・日を含む UInt32 の数値 (YYYY * 10000 + MM * 100 + DD) を返します。UInt32

例

別のタイムゾーンで日付を YYYYMMDD フォーマットに変換する

SELECT toYYYYMMDD(toDateTime('2026-01-02 03:04:05', 'UTC'), 'US/Eastern')

┌─toYYYYMMDD(toDateTime('2026-01-02 03:04:05', 'UTC'), 'US/Eastern')─┐
│                                                           20260101 │
└────────────────────────────────────────────────────────────────────┘

toYYYYMMDDhhmmss

導入バージョン: v1.1.0

日付または日時を、年、月、日、時、分、秒を含む UInt64 の数値 (YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss) に変換します。 2 番目の任意の引数としてタイムゾーンを受け取ります。指定する場合、タイムゾーンは文字列定数である必要があります。

構文

toYYYYMMDDhhmmss(datetime[, timezone])

引数

datetime — 変換する日付または日時。Date または Date32 または DateTime または DateTime64
timezone — 任意。変換に使用するタイムゾーンです。指定する場合、タイムゾーンは文字列定数である必要があります。String

戻り値

年、月、日、時、分、秒を含む UInt64 型の数値を返します (YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss) 。UInt64

例

日付と時刻を YYYYMMDDhhmmss 形式に変換

SELECT toYYYYMMDDhhmmss(toDateTime('2023-03-02 16:22:09', 'UTC'), 'US/Eastern')

┌─toYYYYMMDDhhmmss(toDateTime('2023-03-02 16:22:09', 'UTC'), 'US/Eastern')─┐
│                                                           20230302112209 │
└──────────────────────────────────────────────────────────────────────────┘

toYear

導入バージョン: v1.1.0

Date または DateTime 型の値の年の部分 (西暦) を返します。

構文

toYear(datetime)

別名: YEAR

引数

datetime — 年を取得する対象の日付または日時。Date または Date32 または DateTime または DateTime64

戻り値

指定された Date または DateTime の年を表す UInt16 を返します

例

使用例

SELECT toYear(toDateTime('2023-04-21 10:20:30'))

┌─toYear(toDateTime('2023-04-21 10:20:30'))─┐
│                                      2023 │
└───────────────────────────────────────────┘

toYearNumSinceEpoch

導入バージョン: v25.3.0

1970年からの経過年数を返します

構文

toYearNumSinceEpoch(date)

引数

date — 変換対象の日付または日時。Date または DateTime または DateTime64

戻り値

正の整数

例

SELECT toYearNumSinceEpoch(toDate('2024-10-01'))

toYearWeek

導入バージョン: v20.1.0

日付に対応する年と週を返します。年の最初と最後の週では、結果の年が日付引数の年と異なる場合があります。

mode 引数は、toWeek() の mode 引数と同様に機能します。

警告: toYearWeek() が返す週番号は、toWeek() が返すものと異なる場合があります。toWeek() は常に指定された年における週番号を返しますが、toWeek() が 0 を返す場合、toYearWeek() は前年の最後の週に対応する値を返します。以下の例の prev_yearWeek を参照してください。

最初の引数には、parseDateTime64BestEffort がサポートするフォーマットの String も指定できます。文字列引数のサポートは、特定のサードパーティツールで想定されている MySQL との互換性のためにのみ提供されています。文字列引数のサポートは将来的に新しい MySQL 互換設定に依存するようになる可能性があり、また文字列のパースは一般に低速であるため、使用しないことを推奨します。

構文

toYearWeek(datetime[, mode[, timezone]])

別名: yearweek

引数

datetime — 年と週を取得する日付または日時。Date または DateTime
mode — 任意。モード 0 ～ 9 は、週の開始曜日と週番号の範囲を決定します。デフォルトは 0。- timezone — 任意。タイムゾーン。String

戻り値

年と週番号を組み合わせた整数値を返します。UInt32

例

異なるモードで年と週の組み合わせを取得する

SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9, toYearWeek(toDate('2022-01-01')) AS prev_yearWeek

┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │    201652 │    201652 │    201701 │        202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘

today

導入バージョン: v1.1.0

クエリ解析時点での現在の日付を返します。toDate(now()) と同じです。

構文

today()

別名: current_date, curdate

引数

なし

戻り値

現在の日付 Date を返します。

例

使用例

SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty

┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃      today ┃    curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2026-08-02 │ 2026-08-02 │   2026-08-02 │
└────────────┴────────────┴──────────────┘

SQL 標準構文

SELECT TODAY, CURDATE,CURRENT_DATE

┌──────TODAY─┬────CURDATE─┬─CURRENT_DATE─┐
│ 2026-08-02 │ 2026-08-02 │   2026-08-02 │
└────────────┴────────────┴──────────────┘

yesterday

導入バージョン: v1.1.0

引数を受け取らず、クエリ解析中のある時点における昨日の日付を返します。

構文

yesterday()

引数

なし。

戻り値

昨日の日付を返します。Date

例

昨日の日付を取得

SELECT yesterday();
SELECT today() - 1;

┌─yesterday()─┐
│  2026-08-01 │
└─────────────┘
┌─minus(today(), 1)─┐
│        2026-08-01 │
└───────────────────┘