メインコンテンツへスキップ
このセクションのほとんどの関数では、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)
引数 戻り値 指定された引数から Date 型の値を返します Date 例 例
Query
SELECT YYYYMMDDToDate(20230911);
Response
┌─toYYYYMMDD(20230911)─┐
│           2023-09-11 │
└──────────────────────┘

​
YYYYMMDDToDate32

導入バージョン: v23.9.0 年、月、日を表す数値を Date32 に変換します。 この関数は、toYYYYMMDD() 関数の逆です。 入力が有効な Date32 値を表していない場合、出力は未定義です。 構文 
YYYYMMDDToDate32(YYYYMMDD)
引数 戻り値 指定された引数から 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 例 日付に 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 に 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 に 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)
引数 戻り値 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 に 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 に 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 に 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 に 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 に 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 に 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 に 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 に 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設定可能な値
nanosecondnanosecond, nanoseconds, ns
microsecondmicrosecond, microseconds, us, u
millisecondmillisecond, milliseconds, ms
secondsecond, seconds, ss, s
minuteminute, minutes, mi, n
hourhour, hours, hh, h
dayday, days, dd, d
weekweek, weeks, wk, ww
monthmonth, months, mm, m
quarterquarter, quarters, qq, q
yearyear, 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 例 使用例
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 と同じ型で、分の部分が変更された値を返します。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 と同じ型の値を返します。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 例 使用例
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 と同じ型の値を返します。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 例 使用例
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設定可能な値
nanosecondnanosecond, nanoseconds, ns
microsecondmicrosecond, microseconds, us, u
millisecondmillisecond, milliseconds, ms
secondsecond, seconds, ss, s
minuteminute, minutes, mi, n
hourhour, hours, hh, h
dayday, days, dd, d
weekweek, weeks, wk, ww
monthmonth, months, mm, m
quarterquarter, quarters, qq, q
yearyear, 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 Argumentdatetime ArgumentReturn Type
Year, Quarter, Month, WeekDate32 or DateTime64 or Date or DateTimeDate32 or Date
Day, Hour, Minute, SecondDate32, DateTime64, Date, or DateTimeDateTime64 or DateTime
Millisecond, Microsecond,AnyDateTime64
Nanosecondwith 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 をフォーマットした結果を示しています。 置換フィールド:
PlaceholderDescriptionExample
%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
%gISO 8601 に準拠した 2 桁の年形式18
%GISO の週番号に対応する 4 桁の年形式2018
%h12 時間形式の時 (01-12)09
%H24 時間形式の時 (00-23)22
%i分 (00-59)33
%I12 時間形式の時 (01-12)10
%j年内通算日 (001-366)002
%k24 時間形式の時 (00-23)14
%l12 時間形式の時 (01-12)09
%m月を整数で表したもの (01-12)01
%M完全な月名 (January-December)January
%n改行文字
%pAM または PM 表記PM
%Q四半期 (1-4)1
%r12 時間 HH:MM AM/PM 形式の時刻。%h:%i %p と同等10:30 PM
%R24 時間 HH:MM 形式の時刻。%H:%i と同等22:33
%s秒 (00-59)44
%S秒 (00-59)44
%t水平タブ文字
%TISO 8601 時刻形式 (HH:MM:SS)。%H:%i:%S と同等22:33:44
%u月曜を 1 とする ISO 8601 の曜日番号 (1-7)2
%VISO 8601 の週番号 (01-53)01
%w日曜を 0 とする整数の曜日番号 (0-6)2
%W完全な曜日名 (Monday-Sunday)Monday
%y年の下 2 桁 (00-99)18
%Y年2018
%zUTC からの時差。+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 通りの方法で呼び出せます。 構文 
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)
引数 戻り値 指定された引数から構築された 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)
引数 戻り値 指定した引数から生成された 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])
引数 戻り値 指定された引数から構築された 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]]])
引数 戻り値 指定された引数から構築された 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)
引数 戻り値 月名を返します。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 から 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 から 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 から 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 から 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 から 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 から 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 から 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 から 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 から 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 から 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)
引数 戻り値 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 引数 戻り値 指定された日付/日時の月の日を返します。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 引数 戻り値 指定した 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)
引数 戻り値 指定された日付または日時が属する月の日数を返します。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 の時 (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)
引数 戻り値 入力値を 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 の分におけるミリ秒 (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 の分 (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)
引数 戻り値 修正ユリウス日番号を返します。Int32 例 日付を修正ユリウス日番号に変換
Query
SELECT toModifiedJulianDay('2020-01-01')
Response
┌─toModifiedJulianDay('2020-01-01')─┐
│                             58849 │
└───────────────────────────────────┘

​
toModifiedJulianDayOrNull

導入バージョン: v21.1.0 toModifiedJulianDay() と同様ですが、例外を発生させる代わりに NULL を返します。 構文 
toModifiedJulianDayOrNull(date)
引数 戻り値 有効な 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 引数 戻り値 指定した日付または日時の月を返します。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)
引数 戻り値 正の整数 例 例
Query
SELECT toMonthNumSinceEpoch(toDate('2024-10-01'))
Response
657

​
toQuarter

導入バージョン: v1.1.0 指定された Date または DateTime の値に対応する年の四半期 (1～4) を返します。 構文 
toQuarter(datetime)
別名: QUARTER 引数 戻り値 指定した日付または日時に対応する年の四半期を返します。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)
引数 戻り値 過去のある固定された基準時点からの日数を返します。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)
引数 戻り値 過去の固定された基準時点からの経過時間数を返します。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)
引数 戻り値 過去の固定された基準時点からの分単位の数を返します。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)
引数 戻り値 過去のある固定の基準時点からの経過月数を返します。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)
引数 戻り値 過去のある固定された基準時点からの四半期数を返します。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)
引数 戻り値 過去のある固定された基準時点からの秒数を返します。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)
引数 戻り値 過去のある固定された基準時点からの週数を返します。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)
引数 戻り値 過去の固定基準時点からの年数を返します。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 の分の秒 (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)
引数 戻り値 最も近い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 引数 戻り値 日時を直近の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 または 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)
引数 戻り値 指定した日付または日時に対応する 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) と同じ結果を返します。
計算は、特定の時点を基準に行われます。
インターバル開始点
YEAR0年
QUARTER1900年第1四半期
MONTH1900年1月
WEEK1970年の第1週 (01-05)
DAY1970-01-01
HOUR(*)
MINUTE1970-01-01 00:00:00
SECOND1970-01-01 00:00:00
MILLISECOND1970-01-01 00:00:00
MICROSECOND1970-01-01 00:00:00
NANOSECOND1970-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 または 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)
引数 戻り値 指定した日付または日時の月初を返します。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)
引数 戻り値 最も近い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)
引数 戻り値 指定した日付/時刻が属する年の最初の日を返します。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 引数 戻り値 入力と同じタイムスタンプを、指定したタイムゾーンの 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 引数の動作を示しています。
ModeFirst day of weekRangeWeek 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-531 月 1 日を含む
9月曜日1-531 月 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 引数 戻り値 指定された 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)
引数 戻り値 正の整数 例 例
Query
SELECT toYearNumSinceEpoch(toDate('2024-10-01'))
Response
54

​
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月12日