日付と時刻を扱う関数 - ClickHouse Documentation

このセクションのほとんどの関数では、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 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘

SQL標準との互換性のため、次の関数 NOW、CURRENT_TIMESTAMP、TODAY、CURRENT_DATE は、括弧を付けずに使用できます。

UTCTimestamp

導入バージョン: v22.11.0 クエリ分析時点の現在の日時を返します。この関数は定数式です。この関数は、now('UTC') と同じ結果を返します。追加されたのは MySQL サポートのためだけです。推奨される使用方法は now です。構文

UTCTimestamp()

別名: UTC_timestamp 引数

なし。

戻り値 クエリ解析時点における現在の日付と時刻を返します。DateTime 例 現在の UTC タイムスタンプを取得

Query

SELECT UTCTimestamp()

Response

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

YYYYMMDDToDate

導入バージョン: v23.9.0 年、月、日を含む数値を Date に変換します。この関数は、toYYYYMMDD() 関数の逆です。入力が有効な Date 値を表していない場合、出力は未定義です。構文

YYYYMMDDToDate(YYYYMMDD)

引数

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

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

Query

SELECT YYYYMMDDToDate(20230911);

Response

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

YYYYMMDDToDate32

導入バージョン: v23.9.0 年、月、日を表す数値を Date32 に変換します。この関数は、toYYYYMMDD() 関数の逆です。入力が有効な Date32 値を表していない場合、出力は未定義です。構文

YYYYMMDDToDate32(YYYYMMDD)

引数

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

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

Query

SELECT YYYYMMDDToDate32(20000507);

Response

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

YYYYMMDDhhmmssToDateTime

導入バージョン: v23.9.0 年、月、日、時、分、秒を含む数値を DateTime に変換します。この関数は、toYYYYMMDDhhmmss() 関数の逆です。入力が有効な DateTime 値を表していない場合、出力は未定義です。構文

YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])

引数

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

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

Query

SELECT YYYYMMDDToDateTime(20230911131415);

Response

┌──────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 例例

Query

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

Response

┌─YYYYMMDDhhmm⋯/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 例 日付に interval を加算

Query

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

Response

┌─addDate(toDa⋯valYear(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 例 異なる日付型に日数を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('1⋯valDay(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) 例 異なる日付型に時間を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('1⋯alHour(10))─┐
│      1998-06-16 10:00:00 │
└──────────────────────────┘

addInterval

導入バージョン: v22.11.0 あるインターバルを、別のインターバルまたはインターバルのタプルに加算します。

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

構文

addInterval(interval_1, interval_2)

引数

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

戻り値 インターバルのタプル Tuple(Interval) を返します例 インターバルの加算

Query

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)

Response

┌─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 例 異なる日時型にマイクロ秒を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('19⋯osecond(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 例 異なる日時型にミリ秒を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('1⋯second(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) 例 異なる日付型に分を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('1⋯Minute(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 例 さまざまな日付型に月を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('1⋯lMonth(10))─┐
│               1999-04-16 │
└──────────────────────────┘

addNanoseconds

導入バージョン: v22.6.0 指定したナノ秒数を、日時または文字列としてエンコードされた日時に加算します。構文

addNanoseconds(datetime, num)

引数

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

戻り値 datetime に num ナノ秒を加算した値を返します。 DateTime64 例 さまざまな日時型にナノ秒を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('199⋯osecond(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 例 異なる日付型に四半期を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('1⋯uarter(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) 例 異なる日付型に秒を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─dateAdd('1998-06-16'::Date, INTERVAL 10 second)─┐
│                             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 を加算する

Query

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

Response

┌─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 例 さまざまな日付型に週を加算

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('1⋯alWeek(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 例 異なる日付型に年を加算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─plus(CAST('1⋯alYear(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 例 年齢を時間単位で計算する

Query

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

Response

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

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

Query

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

Response

┌──────────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 例 使用例

Query

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

Response

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 例 使用例

Query

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

Response

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 例 使用例

Query

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

Response

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 例 使用例

Query

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

Response

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 例 使用例

Query

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

Response

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 例 使用例

Query

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

Response

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 例 日付の差を時間単位で計算する

Query

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

Response

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

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

Query

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

Response

┌──────────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 例 さまざまな日付要素を抽出する

Query

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

Response

┌─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

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

Query

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

Response

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

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

Query

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

Response

┌───────────────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 例 年のプレースホルダーを使って日付をフォーマットする

Query

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

Response

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

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

Query

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

Response

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

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

Query

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

Response

┌──────────────────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 をフォーマットする

Query

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

Response

┌─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 年からの日数を日付に変換

Query

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

Response

┌──────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年からの経過日数を日付に変換する

Query

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

Response

┌──────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 例 修正ユリウス日を日付に変換

Query

SELECT fromModifiedJulianDay(58849)

Response

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

fromModifiedJulianDayOrNull

導入バージョン: v21.1.0 fromModifiedJulianDay() と同様ですが、例外をスローする代わりに NULL を返します。構文

fromModifiedJulianDayOrNull(day)

引数

day — 修正ユリウス日番号。(U)Int*

戻り値 day 引数が有効な場合はテキスト形式の日付を返し、それ以外の場合は null を返します。Nullable(String) 例 null を処理しながら修正ユリウス日を日付に変換する

Query

SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- 無効な引数、NULLを返す

Response

┌─fromModified⋯Null(58849)─┐
│ 2020-01-01               │
└──────────────────────────┘
┌─fromModified⋯l(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タイムゾーンを指定したタイムゾーンに変換します

Query

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

Response

┌─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 — 任意。出力のフォーマットに使用する定数の format string。String
timezone — 任意。定数の time zone 文字列。String

戻り値 引数が 1 つの場合は timestamp の DateTime を返し、引数が 2 つまたは 3 つの場合は String を返します。DateTime または String 例 Unixタイムスタンプを DateTime に変換する

Query

SELECT fromUnixTimestamp(423543535)

Response

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

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

Query

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

Response

┌─DateTime────────────┐
│ 2009-02-11 14: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タイムスタンプを変換

Query

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

Response

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

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 例 年、月、日から日付を作成

Query

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

Response

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

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

Query

SELECT makeDate(2023, 42) AS date;

Response

┌───────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 を生成

Query

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

Response

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

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

Query

SELECT makeDate(2023, 42) AS date;

Response

┌───────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 を構築

Query

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

Response

┌────────────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 を作成

Query

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

Response

┌─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 例 日付から月名を取得する

Query

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

Response

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

now

導入バージョン: v1.1.0 クエリの解析時点における現在の日付と時刻を返します。この関数は定数式です。構文

now([timezone])

別名: current_timestamp 引数

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

戻り値 現在の日付と時刻を返します。DateTime 例 タイムゾーンを指定しないクエリ

Query

SELECT now()

Response

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

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

Query

SELECT now('Asia/Istanbul')

Response

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

SQL 標準構文

Query

SELECT NOW, CURRENT_TIMESTAMP

Response

┌─────────────────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 例 デフォルトおよびカスタムの精度を指定したクエリ

Query

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

Response

┌─────────────────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() 関数との違い

Query

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

Response

┌───────────────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() 関数との違い

Query

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

Response

┌─────────────────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 で返します例 使用例

Query

SELECT serverTimeZone()

Response

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

subDate

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

subDate(datetime, interval)

引数

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

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

Query

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

Response

┌─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 例 異なる日付型から日数を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('⋯valDay(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) 例 異なる日付型から時間を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('⋯alHour(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) を返します例 インターバルを減算する

Query

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);

Response

┌─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 例 さまざまな日時型からマイクロ秒を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('1⋯osecond(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 例 さまざまな日時型からミリ秒を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('⋯second(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) 例 さまざまな日付型から分を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('⋯Minute(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 例 さまざまな日付型から月を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('⋯lMonth(10))─┐
│               1997-08-16 │
└──────────────────────────┘

subtractNanoseconds

導入バージョン: v20.1.0 日時、または日時を表す文字列から、指定したナノ秒数を減算します。構文

subtractNanoseconds(datetime, num)

引数

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

戻り値 datetime から num ナノ秒を減算した結果を返します。 DateTime64 例 異なる日時型からナノ秒を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('19⋯anosecond(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 例 異なる日付型で四半期を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('1⋯Quarter(10))─┐
│                1996-09-16 │
└───────────────────────────┘

subtractSeconds

導入バージョン: v1.1.0 指定した秒数を、日付、日時、または文字列として表現された日付もしくは日時から減算します。構文

subtractSeconds(datetime, num)

引数

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

戻り値 datetime から num 秒を減算した値を返します。DateTime または DateTime64(3) 例 異なる日付型から秒数を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('⋯Second(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 例 日付からインターバルのタプルを減算する

Query

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

Response

┌─subtractTupl⋯alYear(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 例 さまざまな日付型から週を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('⋯alWeek(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 例 異なる日付型から年を減算する

Query

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

Response

┌─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 構文の使用

Query

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

Response

┌─minus(CAST('⋯alYear(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 例 秒単位の時刻差を計算する

Query

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

Response

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

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

Query

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

Response

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

dateDiff の seconds 指定と同等

Query

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

Response

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

timeSlot

導入バージョン: v1.1.0 時刻を30分単位の時間区間の開始時刻に丸めます。

この関数は拡張型 Date32 と DateTime64 の値も引数として受け取れますが、通常の範囲外の時刻 (Date は 1970 年から 2149 年、DateTime は 2106 年まで) を渡すと、誤った結果になります。

構文

timeSlot(time[, time_zone])

引数

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

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

Query

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

Response

┌─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) 例 期間の時間スロットを生成する

Query

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))

Response

┌─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) に変換

Query

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

Response

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

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

Query

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

Response

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

timezone

導入バージョン: v21.4.0 現在のセッションのタイムゾーン名を返すか、タイムゾーンのオフセットまたは名前を正規のタイムゾーン名に変換します。構文

timezone()

別名: timeZone 引数

なし。

戻り値 String型の正規のタイムゾーン名を返します例 使用例

Query

SELECT timezone()

Response

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

timezoneOf

導入バージョン: v21.4.0 DateTime または DateTime64 の値に設定されたタイムゾーン名を返します。構文

timezoneOf(datetime)

別名: timeZoneOf 引数

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

戻り値 datetime のタイムゾーン名を返します。String 例 使用例

Query

SELECT timezoneOf(now());

Response

┌─timezoneOf(now())─┐
│ Europe/Amsterdam  │
└───────────────────┘

timezoneOffset

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

timezoneOffset(datetime)

別名: timeZoneOffset 引数

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

戻り値 UTC からのオフセットを秒単位で返します。Int32 例 使用例

Query

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;

Response

┌────────────────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 例 使用例

Query

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

Response

┌─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 例 使用例

Query

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

Response

┌─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 例 使用例

Query

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

Response

┌─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 例 使用例

Query

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

Response

┌─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 年からの経過日数を計算する

Query

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

Response

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

toHour

導入バージョン: v1.1.0 DateTime または DateTime64 の値から、時の部分 (0～23) を返します。構文

toHour(datetime)

別名: HOUR 引数

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

戻り値 datetime の時 (0～23) を返します。UInt8 例 使用例

Query

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

Response

┌─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 週番号を取得する

Query

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

Response

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

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

Query

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

Response

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

toISOYear

導入バージョン: v18.4.0 日付または日時を ISO 年番号に変換します。構文

toISOYear(datetime)

引数

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

戻り値 入力値を ISO年の番号に変換して返します。UInt16 例 日付の値から ISO年を取得する

Query

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

Response

┌─week1─┬─week2─┐
│    40 │    40 │
└───────┴───────┘

toLastDayOfMonth

導入バージョン: v1.1.0 日付または日時を、その月の末日に切り上げます。

戻り値の型は、enable_extended_results_for_datetime_functions を設定することで指定できます。

構文

toLastDayOfMonth(value)

別名: LAST_DAY 引数

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

戻り値 指定された日付または日時が属する月の末日の日付を返します。Date 例 その月の末日に切り上げる

Query

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

Response

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

toLastDayOfWeek

導入バージョン: v23.5.0 日付または日時を、最も近い土曜日または日曜日まで切り上げます。

戻り値の型は、enable_extended_results_for_datetime_functions を設定することで変更できます。

構文

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

引数

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

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

Query

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

Response

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

toMillisecond

導入バージョン: v24.2.0 DateTime または DateTime64 の値のミリ秒部分 (0～999) を返します。構文

toMillisecond(datetime)

別名: MILLISECOND 引数

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

戻り値 datetime の分におけるミリ秒 (0 - 59) を返します。UInt16 例 使用例

Query

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

Response

┌──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 例 使用例

Query

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

Response

┌─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 例 日付を修正ユリウス日番号に変換

Query

SELECT toModifiedJulianDay('2020-01-01')

Response

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

toModifiedJulianDayOrNull

導入バージョン: v21.1.0 toModifiedJulianDay() と同様ですが、例外を発生させる代わりに NULL を返します。構文

toModifiedJulianDayOrNull(date)

引数

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

戻り値 有効な date の修正ユリウス日番号を返し、それ以外の場合は NULL を返します。Nullable(Int32) 例 NULL を処理しながら日付を修正ユリウス日に変換

Query

SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- 無効な日付、NULLを返す

Response

┌─toModifiedJu⋯020-01-01')─┐
│                    58849 │
└──────────────────────────┘
┌─toModifiedJu⋯000-00-00')─┐
│                     ᴺᵁᴸᴸ │
└──────────────────────────┘

toMonday

導入バージョン: v1.1.0 日付または日時を、同じ週の月曜日に切り下げます。日付を返します。

戻り値の型は、enable_extended_results_for_datetime_functions の設定によって変更できます。

構文

toMonday(value)

引数

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

戻り値 指定された日付または日時が属する週の月曜日の日付を返します。Date 例 その週の月曜日に切り下げる

Query

SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- 金曜日
toMonday(toDate('2023-04-24'));              -- すでに月曜日

Response

┌─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 例 使用例

Query

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

Response

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

toMonthNumSinceEpoch

導入バージョン: v25.3.0 1970年からの経過月数を返します構文

toMonthNumSinceEpoch(date)

引数

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

戻り値 正の整数例例

Query

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

Response

toQuarter

導入バージョン: v1.1.0 指定された Date または DateTime の値に対応する年の四半期 (1～4) を返します。構文

toQuarter(datetime)

別名: QUARTER 引数

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

戻り値 指定した日付または日時に対応する年の四半期を返します。UInt8 例 使用例

Query

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

Response

┌─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 例 相対的な日数を取得

Query

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

Response

┌─minus(toRela⋯3-01-01')))─┐
│                       90 │
└──────────────────────────┘

toRelativeHourNum

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

toRelativeHourNum(date)

引数

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

戻り値 過去の固定された基準時点からの経過時間数を返します。UInt32 例 相対時間数を取得する

Query

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

Response

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

toRelativeMinuteNum

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

toRelativeMinuteNum(date)

引数

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

戻り値 過去の固定された基準時点からの分単位の数を返します。UInt32 例 相対的な分番号を取得

Query

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

Response

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

toRelativeMonthNum

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

toRelativeMonthNum(date)

引数

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

戻り値 過去のある固定の基準時点からの経過月数を返します。UInt32 例 相対月番号を取得する

Query

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

Response

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

toRelativeQuarterNum

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

toRelativeQuarterNum(date)

引数

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

戻り値 過去のある固定された基準時点からの四半期数を返します。UInt32 例 相対四半期番号を取得

Query

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

Response

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

toRelativeSecondNum

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

toRelativeSecondNum(date)

引数

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

戻り値 過去のある固定された基準時点からの秒数を返します。UInt32 例 相対秒数を取得

Query

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

Response

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

toRelativeWeekNum

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

toRelativeWeekNum(date)

引数

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

戻り値 過去のある固定された基準時点からの週数を返します。UInt32 例 相対週番号を取得する

Query

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

Response

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

toRelativeYearNum

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

toRelativeYearNum(date)

引数

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

戻り値 過去の固定基準時点からの年数を返します。UInt16 例 相対年番号を取得

Query

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

Response

┌─minus(toRela⋯ateTime')))─┐
│                       10 │
└──────────────────────────┘

toSecond

導入バージョン: v1.1.0 DateTime または DateTime64 の値から秒の部分 (0～59) を返します。構文

toSecond(datetime)

別名: SECOND 引数

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

戻り値 datetime の分の秒 (0 - 59) を返します。UInt8 例 使用例

Query

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

Response

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

toStartOfDay

導入バージョン: v1.1.0 日時をその日の開始時刻に切り下げます。

戻り値の型は、enable_extended_results_for_datetime_functions の設定で変更できます。

構文

toStartOfDay(datetime)

引数

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

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

Query

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

Response

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

toStartOfFifteenMinutes

導入バージョン: v1.1.0 日時を15分間隔の開始時点に切り下げます。

戻り値の型は、enable_extended_results_for_datetime_functions を設定することで変更できます。

構文

toStartOfFifteenMinutes(datetime)

引数

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

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

Query

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

Response

行 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 分間隔の開始時点に切り下げます。

戻り値の型は、enable_extended_results_for_datetime_functions の設定で変更できます。

構文

toStartOfFiveMinutes(datetime)

別名: toStartOfFiveMinute 引数

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

戻り値 日時を直近の5分単位の開始時刻に丸めた値を返します。DateTime または DateTime64 例例

Query

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

Response

行 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 日時をその時間の開始時刻に切り下げます。

戻り値の型は、enable_extended_results_for_datetime_functions の設定で変更できます。

構文

toStartOfHour(datetime)

引数

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

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

Query

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

Response

┌─────────────────res─┬─toTypeName(res)─┐
│ 2023-04-21 10:00:00 │ DateTime        │
└─────────────────────┴─────────────────┘

toStartOfISOYear

導入バージョン: v1.1.0 日付または日時を ISO 年の最初の日まで切り下げます。これは通常の暦年とは異なる場合があります。ISO 週日付を参照してください。

戻り値の型は、enable_extended_results_for_datetime_functions の設定で変更できます。

構文

toStartOfISOYear(value)

引数

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

戻り値 指定した日付または日時に対応する ISO 年の初日を返します。Date 例 ISO 年の初日に切り下げる

Query

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

Response

┌─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]])

別名: time_bucket, date_bin 引数

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

戻り値 入力値を含む間隔の開始時点を返します。DateTime 例 基本的な間隔の丸め

Query

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

Response

┌─toStartOfInt⋯alMonth(1))─┐
│               2023-01-01 │
└──────────────────────────┘

始点を使用する

Query

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

Response

┌─toStartOfInt⋯14:35:30'))─┐
│      2023-01-01 14:44:30 │
└──────────────────────────┘

toStartOfMicrosecond

導入バージョン: v22.6.0 日時をマイクロ秒の開始時点に切り捨てます。構文

toStartOfMicrosecond(datetime[, timezone])

引数

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

戻り値 マイクロ秒未満を含む入力値。DateTime64 例 タイムゾーンを指定しないクエリ

Query

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

Response

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

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

Query

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

Response

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

toStartOfMillisecond

導入バージョン: v22.6.0 日時をミリ秒の先頭に切り下げます。構文

toStartOfMillisecond(datetime[, timezone])

引数

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

戻り値 ミリ秒未満の精度を含む入力値。DateTime64 例 タイムゾーンを指定しないクエリ

Query

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

Response

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

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

Query

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

Response

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

toStartOfMinute

導入バージョン: v1.1.0 日時をその分の先頭に切り捨てます。

戻り値の型は、enable_extended_results_for_datetime_functions の設定によって変更できます。

構文

toStartOfMinute(datetime)

引数

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

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

Query

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

Response

行 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 date または日時をその月の初日に切り下げます。

戻り値の型は、enable_extended_results_for_datetime_functions の設定によって変更できます。

構文

toStartOfMonth(value)

引数

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

戻り値 指定した日付または日時の月初を返します。Date 例 月初に切り下げる

Query

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

Response

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

toStartOfNanosecond

導入バージョン: v22.6.0 日時をナノ秒単位の先頭に切り捨てます。構文

toStartOfNanosecond(datetime[, timezone])

引数

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

戻り値 ナノ秒を含む入力値。DateTime64 例 タイムゾーンを指定しないクエリ

Query

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

Response

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

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

Query

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

Response

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

toStartOfQuarter

導入バージョン: v1.1.0 日付または日時を、その四半期の初日に切り下げます。四半期の初日は、1月1日、4月1日、7月1日、または10月1日です。

戻り値の型は、enable_extended_results_for_datetime_functions の設定によって変更できます。

構文

toStartOfQuarter(value)

引数

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

戻り値 指定された日付または日時に対応する四半期の初日を返します。Date 例 四半期の初日に切り下げる

Query

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

Response

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

toStartOfSecond

導入バージョン: v20.5.0 日時を秒の開始時刻に切り捨てます。構文

toStartOfSecond(datetime[, timezone])

引数

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

戻り値 小数秒を除いた入力値を返します。DateTime64 例 タイムゾーンを指定しないクエリ

Query

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

Response

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

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

Query

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

Response

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

toStartOfTenMinutes

導入バージョン: v20.1.0 日時を、その時刻を含む10分間隔の開始時刻に切り下げます。

戻り値の型は、enable_extended_results_for_datetime_functions の設定によって変更できます。

構文

toStartOfTenMinutes(datetime)

引数

datetime — 日時。DateTime または DateTime64

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

Query

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

Response

行 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 日付または日時を、直前の日曜日または月曜日に切り下げます。

戻り値の型は、enable_extended_results_for_datetime_functions の設定で変更できます。

構文

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

引数

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

戻り値 mode に応じて、指定した日付当日またはそれ以前の直近の日曜日または月曜日の日付を返します。Date または Date32 例 直近の日曜日または月曜日に切り下げる

Query

SELECT
        toStartOfWeek(toDateTime('2023-04-21 10:20:30')), /* 金曜日 */
        toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* 金曜日 */
        toStartOfWeek(toDate('2023-04-24')), /* 月曜日 */
        toStartOfWeek(toDate('2023-04-24'), 1) /* 月曜日 */
    FORMAT Vertical

Response

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

toStartOfYear

導入バージョン: v1.1.0 日付または日時を、その年の最初の日に切り下げます。結果は Date オブジェクトとして返されます。

戻り値の型は、enable_extended_results_for_datetime_functions の設定によって変更できます。

構文

toStartOfYear(value)

引数

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

戻り値 指定した日付/時刻が属する年の最初の日を返します。Date 例 年の最初の日に切り下げる

Query

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

Response

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

toTimeWithFixedDate

導入バージョン: v1.1.0 日付または日時から時間部分を抽出します。返される値は固定された時点からのオフセットで、現在は 1970-01-02 が使われていますが、どの時点を基準とするかは実装の詳細であり、将来変更される可能性があります。したがって、toTime を単独で使用するべきではありません。この関数の主な用途は、2 つの日付または日時の時間差を計算することです。たとえば、toTime(dt1) - toTime(dt2) のように使用します。構文

toTimeWithFixedDate(date[, timezone])

引数

date — 時刻に変換する日付または日時。Date または DateTime または DateTime64
timezone — 省略可。戻り値に使用するタイムゾーン。String

戻り値 固定の時点 (現在は 1970-01-02) からのオフセットとして、日付または日時の時刻部分を返します。DateTime 例 2 つの日付の時刻差を計算する

Query

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

Response

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

toTimezone

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

toTimezone(datetime, timezone)

別名: toTimeZone 引数

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

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

Query

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;

Response

行 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 に変換する

Query

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

Response

┌─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 例 使用例

Query

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;

Response

行 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 例 異なるモードで週番号を取得する

Query

SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9

Response

┌───────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 形式に変換する

Query

SELECT toYYYYMM(now(), 'US/Eastern')

Response

┌─toYYYYMM(now(), 'US/Eastern')─┐
│                        202303 │
└───────────────────────────────┘

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 フォーマットに変換する

Query

SELECT toYYYYMMDD(now(), 'US/Eastern')

Response

┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│                        20230302 │
└─────────────────────────────────┘

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 形式に変換

Query

SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')

Response

┌─toYYYYMMDDhhmmss(now(), 'US/Eastern')─┐
│                        20230302112209 │
└───────────────────────────────────────┘

toYear

導入バージョン: v1.1.0 Date または DateTime 型の値の年の部分 (西暦) を返します。構文

toYear(datetime)

別名: YEAR 引数

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

戻り値 指定された Date または DateTime の年を表す UInt16 を返します例 使用例

Query

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

Response

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

toYearNumSinceEpoch

導入バージョン: v25.3.0 1970年からの経過年数を返します構文

toYearNumSinceEpoch(date)

引数

date — 変換対象の日付または日時。Date または DateTime または DateTime64

戻り値 正の整数例例

Query

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

Response

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 例 異なるモードで年と週の組み合わせを取得する

Query

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

Response

┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │    201652 │    201652 │    201701 │        202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘

today

導入バージョン: v1.1.0 クエリ解析時点での現在の日付を返します。toDate(now()) と同じです。構文

today()

別名: curdate, current_date 引数

なし

戻り値 現在の日付 Date を返します。例 使用例

Query

SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty

Response

┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃      today ┃    curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-03 │ 2025-03-03 │   2025-03-03 │
└────────────┴────────────┴──────────────┘

SQL 標準構文

Query

SELECT TODAY, CURDATE,CURRENT_DATE

Response

┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃      TODAY ┃    CURDATE ┃ CURRENT_DATE ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-04 │ 2025-03-04 │   2025-03-04 │
└────────────┴────────────┴──────────────┘

yesterday

導入バージョン: v1.1.0 引数を受け取らず、クエリ解析中のある時点における昨日の日付を返します。構文

yesterday()

引数

なし。

戻り値 昨日の日付を返します。Date 例 昨日の日付を取得

Query

SELECT yesterday();
SELECT today() - 1;

Response

┌─yesterday()─┐
│  2025-06-09 │
└─────────────┘
┌─minus(today(), 1)─┐
│        2025-06-09 │
└───────────────────┘

最終更新日 2026年6月19日

距離距離関数に関するドキュメント

​UTCTimestamp

​YYYYMMDDToDate

​YYYYMMDDToDate32

​YYYYMMDDhhmmssToDateTime

​YYYYMMDDhhmmssToDateTime64

​addDate

​addDays

​addHours

​addInterval

​addMicroseconds

​addMilliseconds

​addMinutes

​addMonths

​addNanoseconds

​addQuarters

​addSeconds

​addTupleOfIntervals

​addWeeks

​addYears

​age

​changeDay

​changeHour

​changeMinute

​changeMonth

​changeSecond

​changeYear

​dateDiff

​dateName

​dateTrunc

​formatDateTime

​formatDateTimeInJodaSyntax

​fromDaysSinceYearZero

​fromDaysSinceYearZero32

​fromModifiedJulianDay

​fromModifiedJulianDayOrNull

​fromUTCTimestamp

​fromUnixTimestamp

​fromUnixTimestampInJodaSyntax

​makeDate

​makeDate32

​makeDateTime

​makeDateTime64

​monthName

​now

​now64

​nowInBlock

​nowInBlock64

​serverTimezone

​subDate

​subtractDays

​subtractHours

​subtractInterval

​subtractMicroseconds

​subtractMilliseconds

​subtractMinutes

​subtractMonths

​subtractNanoseconds

​subtractQuarters

​subtractSeconds

​subtractTupleOfIntervals

​subtractWeeks

​subtractYears

​timeDiff

​timeSlot

​timeSlots

​timestamp

​timezone

​timezoneOf

​timezoneOffset

​toDayOfMonth

​toDayOfWeek

​toDayOfYear

​toDaysInMonth

​toDaysSinceYearZero

​toHour

​toISOWeek

​toISOYear

​toLastDayOfMonth

​toLastDayOfWeek

​toMillisecond

UTCTimestamp

YYYYMMDDToDate

YYYYMMDDToDate32

YYYYMMDDhhmmssToDateTime

YYYYMMDDhhmmssToDateTime64

addDate

addDays

addHours

addInterval

addMicroseconds

addMilliseconds

addMinutes

addMonths

addNanoseconds

addQuarters

addSeconds

addTupleOfIntervals

addWeeks

addYears

age

changeDay

changeHour

changeMinute

changeMonth

changeSecond

changeYear

dateDiff

dateName

dateTrunc

formatDateTime

formatDateTimeInJodaSyntax

fromDaysSinceYearZero

fromDaysSinceYearZero32

fromModifiedJulianDay

fromModifiedJulianDayOrNull

fromUTCTimestamp

fromUnixTimestamp

fromUnixTimestampInJodaSyntax

makeDate

makeDate32

makeDateTime

makeDateTime64

monthName

now

now64

nowInBlock

nowInBlock64

serverTimezone

subDate

subtractDays

subtractHours

subtractInterval

subtractMicroseconds

subtractMilliseconds

subtractMinutes

subtractMonths

subtractNanoseconds

subtractQuarters

subtractSeconds

subtractTupleOfIntervals

subtractWeeks

subtractYears

timeDiff

timeSlot

timeSlots

timestamp

timezone

timezoneOf

timezoneOffset

toDayOfMonth

toDayOfWeek

toDayOfYear

toDaysInMonth

toDaysSinceYearZero

toHour

toISOWeek

toISOYear

toLastDayOfMonth

toLastDayOfWeek

toMillisecond