│
└──────────────────────────────────────────────┘
```
## formatRowNoNewline
導入バージョン: v20.7.0
[`formatRow`](#formatRow) と同じですが、各行の改行文字を取り除きます。
指定したフォーマットを使用して任意の式を文字列に変換しますが、結果の末尾にある改行文字はすべて削除されます。
**構文**
```sql theme={null}
formatRowNoNewline(format, x, y, ...)
```
**引数**
* `format` — テキストフォーマット。たとえば、CSV、TSV。 [`String`](/ja/reference/data-types/string)
* `x, y, ...` — 式。 [`Any`](/ja/reference/data-types/index)
**戻り値**
改行が削除されたフォーマット済み文字列を返します。 [`String`](/ja/reference/data-types/string)
**例**
**基本的な使い方**
```sql title=Query theme={null}
SELECT formatRowNoNewline('CSV', number, 'good')
FROM numbers(3)
```
```response title=Response theme={null}
┌─formatRowNoNewline('CSV', number, 'good')─┐
│ 0,"good" │
│ 1,"good" │
│ 2,"good" │
└───────────────────────────────────────────┘
```
## fromUnixTimestamp64Micro
導入バージョン: v20.5.0
マイクロ秒単位の Unixタイムスタンプを、マイクロ秒精度の `DateTime64` 値に変換します。
入力値は、マイクロ秒精度の Unixタイムスタンプ (1970-01-01 00:00:00 UTC からの経過マイクロ秒数) として扱われます。
**構文**
```sql theme={null}
fromUnixTimestamp64Micro(value[, timezone])
```
**引数**
* `value` — マイクロ秒単位の Unix timestamp。[`Int64`](/ja/reference/data-types/int-uint)
* `timezone` — 省略可。戻り値のタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
マイクロ秒精度の `DateTime64` 型の値を返します。[`DateTime64(6)`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Micro(1640995200123456)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Micro(1640995200123456)─┐
│ 2022-01-01 00:00:00.123456 │
└────────────────────────────────────────────┘
```
## fromUnixTimestamp64Milli
導入バージョン: v20.5.0
ミリ秒単位の Unixタイムスタンプを、ミリ秒精度の `DateTime64` 値に変換します。
入力値は、ミリ秒精度の Unixタイムスタンプ (1970-01-01 00:00:00 UTC からの経過ミリ秒数) として扱われます。
**構文**
```sql theme={null}
fromUnixTimestamp64Milli(value[, timezone])
```
**引数**
* `value` — ミリ秒単位の Unixタイムスタンプ。[`Int64`](/ja/reference/data-types/int-uint)
* `timezone` — 省略可能。戻り値のタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
ミリ秒精度の `DateTime64` 値。[`DateTime64(3)`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Milli(1640995200123)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Milli(1640995200123)─┐
│ 2022-01-01 00:00:00.123 │
└─────────────────────────────────────────┘
```
## fromUnixTimestamp64Nano
導入バージョン: v20.5.0
ナノ秒単位の Unixタイムスタンプ を、ナノ秒精度の [`DateTime64`](/ja/reference/data-types/datetime64) 値に変換します。
入力値は、ナノ秒精度の Unixタイムスタンプ (1970-01-01 00:00:00 UTC からのナノ秒数) として扱われます。
入力値は UTC のタイムスタンプとして扱われ、入力値のタイムゾーンは考慮されないことに注意してください。
**構文**
```sql theme={null}
fromUnixTimestamp64Nano(value[, timezone])
```
**引数**
* `value` — ナノ秒単位の Unixタイムスタンプ。[`Int64`](/ja/reference/data-types/int-uint)
* `timezone` — 省略可。戻り値のタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
ナノ秒精度の `DateTime64` 値を返します。[`DateTime64(9)`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Nano(1640995200123456789)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Nano(1640995200123456789)─┐
│ 2022-01-01 00:00:00.123456789 │
└──────────────────────────────────────────────┘
```
## fromUnixTimestamp64Second
導入バージョン: v24.12.0
秒単位の Unixタイムスタンプ を、秒精度の `DateTime64` 値に変換します。
入力値は、秒精度の Unixタイムスタンプ (1970-01-01 00:00:00 UTC からの経過秒数) として扱われます。
**構文**
```sql theme={null}
fromUnixTimestamp64Second(value[, timezone])
```
**引数**
* `value` — 秒単位のUnixタイムスタンプ。 [`Int64`](/ja/reference/data-types/int-uint)
* `timezone` — 省略可能。戻り値のタイムゾーン。 [`String`](/ja/reference/data-types/string)
**戻り値**
秒精度の `DateTime64` 値を返します。 [`DateTime64(0)`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Second(1640995200)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Second(1640995200)─┐
│ 2022-01-01 00:00:00 │
└───────────────────────────────────────┘
```
## parseDateTime
導入バージョン: v23.3.0
MySQL の日付フォーマット文字列に従って、日付と時刻の文字列を解析します。
この関数は [`formatDateTime`](/ja/reference/functions/regular-functions/date-time-functions) の逆関数です。
フォーマット文字列を使用して String 型の引数を解析します。戻り値は DateTime 型です。
**構文**
```sql theme={null}
parseDateTime(time_string, format[, timezone])
```
**別名**: `TO_UNIXTIME`
**引数**
* `time_string` — DateTime に解析する文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` の解析方法を指定するフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
MySQL スタイルのフォーマット文字列に従って入力文字列を解析した DateTime を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
```
```response title=Response theme={null}
┌─parseDateTime('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2025-01-04 23:00:00 │
└───────────────────────────────────────────────────────────┘
```
## parseDateTime32BestEffort
導入バージョン: v20.9.0
日付と時刻の文字列表現を、[`DateTime`](/ja/reference/data-types/datetime)データ型に変換します。
この関数は、[ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)、[RFC 1123 - 5.2.14 RFC-822 Date and Time Specification](https://tools.ietf.org/html/rfc1123#page-55)、ClickHouse独自の形式を含む、いくつかの日付と時刻のフォーマットを解析します。
**構文**
```sql theme={null}
parseDateTime32BestEffort(time_string[, time_zone])
```
**引数**
* `time_string` — 変換する日付と時刻を含む文字列。[`String`](/ja/reference/data-types/string)
* `time_zone` — 省略可。`time_string` の解析に使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
`time_string` を `DateTime` として返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('23/10/2025 12:12:57')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2025-10-23 12:12:57 │
└───────────────────────────┘
```
**タイムゾーンあり**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('Sat, 18 Aug 2025 07:22:16 GMT', 'Asia/Istanbul')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2025-08-18 10:22:16 │
└───────────────────────────┘
```
**Unixタイムスタンプ**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('1284101485')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2015-07-07 12:04:41 │
└───────────────────────────┘
```
## parseDateTime32BestEffortOrNull
導入バージョン: v20.9.0
[`parseDateTime32BestEffort`](#parseDateTime32BestEffort) と同様ですが、処理できない日付フォーマットが指定された場合は `NULL` を返します。
**構文**
```sql theme={null}
parseDateTime32BestEffortOrNull(time_string[, time_zone])
```
**引数**
* `time_string` — 変換する日付と時刻を含む文字列。[`String`](/ja/reference/data-types/string)
* `time_zone` — 省略可。`time_string` のパースに使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
文字列からパースされた `DateTime` オブジェクトを返します。パースに失敗した場合は `NULL` を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
parseDateTime32BestEffortOrNull('23/10/2025 12:12:57') AS valid,
parseDateTime32BestEffortOrNull('invalid date') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─┐
│ 2025-10-23 12:12:57 │ ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```
## parseDateTime32BestEffortOrZero
導入バージョン: v20.9.0
[`parseDateTime32BestEffort`](#parseDateTime32BestEffort) と同様ですが、処理できない日付フォーマットに遭遇した場合は、ゼロ日付またはゼロ日時を返します。
**構文**
```sql theme={null}
parseDateTime32BestEffortOrZero(time_string[, time_zone])
```
**引数**
* `time_string` — 変換する日付と時刻を含む文字列。[`String`](/ja/reference/data-types/string)
* `time_zone` — 省略可能。`time_string` のパース時に使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
文字列からパースされた `DateTime` オブジェクトを返します。パースに失敗した場合は、ゼロ日付 (`1970-01-01 00:00:00`) を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
parseDateTime32BestEffortOrZero('23/10/2025 12:12:57') AS valid,
parseDateTime32BestEffortOrZero('invalid date') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─────────────┐
│ 2025-10-23 12:12:57 │ 1970-01-01 00:00:00 │
└─────────────────────┴─────────────────────┘
```
## parseDateTime64
導入バージョン: v24.11.0
MySQL の日付フォーマット文字列に従って、サブ秒精度の日付と時刻の文字列を解析します。
この関数は、DateTime64 に対する [`formatDateTime`](/ja/reference/functions/regular-functions/date-time-functions) の逆関数です。
フォーマット String を使って String 型の argument を解析します。1900 年から 2299 年までの日付をサブ秒精度で表現できる DateTime64 型を返します。
**構文**
```sql theme={null}
parseDateTime64(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime64 に解析する文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` の解析方法を指定するフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 省略可。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
MySQL 形式のフォーマット文字列に従って入力文字列を解析した DateTime64 を返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')
```
```response title=Response theme={null}
┌─parseDateTime64('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')─┐
│ 2025-01-04 23:00:00.123 │
└─────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64BestEffort
導入バージョン: v20.1.0
[`parseDateTimeBestEffort`](#parseDateTimeBestEffort) 関数と同様ですが、ミリ秒とマイクロ秒もパースし、[`DateTime64`](/ja/reference/data-types/datetime64) データ型を返します。
**構文**
```sql theme={null}
parseDateTime64BestEffort(time_string[, precision[, time_zone]])
```
**引数**
* `time_string` — 変換する日付または日時を含む String。[`String`](/ja/reference/data-types/string)
* `precision` — 任意。必要な精度。ミリ秒は `3`、マイクロ秒は `6`。デフォルト: `3`。[`UInt8`](/ja/reference/data-types/int-uint)
* `time_zone` — 任意。タイムゾーン。関数は `time_zone` に従って `time_string` を解析します。[`String`](/ja/reference/data-types/string)
**戻り値**
`time_string` を [`DateTime64`](/ja/reference/data-types/datetime64) 型に変換して返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffort('2025-01-01') AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2025-01-01 01:01:00.12346') AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2025-01-01 01:01:00.12346',6) AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2025-01-01 01:01:00.12346',3,'Asia/Istanbul') AS a, toTypeName(a) AS t
FORMAT PrettyCompactMonoBlock
```
```response title=Response theme={null}
┌──────────────────────────a─┬─t──────────────────────────────┐
│ 2025-01-01 01:01:00.123000 │ DateTime64(3) │
│ 2025-01-01 00:00:00.000000 │ DateTime64(3) │
│ 2025-01-01 01:01:00.123460 │ DateTime64(6) │
│ 2025-12-31 22:01:00.123000 │ DateTime64(3, 'Asia/Istanbul') │
└────────────────────────────┴────────────────────────────────┘
```
## parseDateTime64BestEffortOrNull
導入バージョン: v20.1.0
[`parseDateTime64BestEffort`](#parseDateTime64BestEffort) と同様ですが、処理できない日付フォーマットに遭遇した場合は `NULL` を返します。
**構文**
```sql theme={null}
parseDateTime64BestEffortOrNull(time_string[, precision[, time_zone]])
```
**引数**
* `time_string` — 変換する日付または日時を含む String。[`String`](/ja/reference/data-types/string)
* `precision` — 任意。必要な精度です。ミリ秒は `3`、マイクロ秒は `6` です。デフォルト: `3`。[`UInt8`](/ja/reference/data-types/int-uint)
* `time_zone` — 任意。タイムゾーン。関数は `time_zone` に従って `time_string` を解析します。[`String`](/ja/reference/data-types/string)
**戻り値**
`time_string` を [`DateTime64`](/ja/reference/data-types/datetime64) に変換して返します。入力を解析できない場合は `NULL` を返します。[`DateTime64`](/ja/reference/data-types/datetime64) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortOrNull('2025-01-01 01:01:00.123') AS valid,
parseDateTime64BestEffortOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────────┬─invalid─┐
│ 2025-01-01 01:01:00.123 │ ᴺᵁᴸᴸ │
└─────────────────────────┴─────────┘
```
## parseDateTime64BestEffortOrZero
導入バージョン: v20.1.0
[`parseDateTime64BestEffort`](#parseDateTime64BestEffort) と同様ですが、処理できない日付フォーマットに遭遇した場合は、ゼロ日付またはゼロ日時を返します。
**構文**
```sql theme={null}
parseDateTime64BestEffortOrZero(time_string[, precision[, time_zone]])
```
**引数**
* `time_string` — 変換する日付または日時を含む文字列。[`String`](/ja/reference/data-types/string)
* `precision` — 任意。必要な精度です。ミリ秒は `3`、マイクロ秒は `6`。デフォルトは `3` です。[`UInt8`](/ja/reference/data-types/int-uint)
* `time_zone` — 任意。タイムゾーンです。関数はこのタイムゾーンに従って `time_string` を解析します。[`String`](/ja/reference/data-types/string)
**戻り値**
`time_string` を [`DateTime64`](/ja/reference/data-types/datetime64) に変換して返します。入力を解析できない場合は、ゼロ日付/日時 (`1970-01-01 00:00:00.000`) を返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortOrZero('2025-01-01 01:01:00.123') AS valid,
parseDateTime64BestEffortOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────────┬─invalid─────────────────┐
│ 2025-01-01 01:01:00.123 │ 1970-01-01 00:00:00.000 │
└─────────────────────────┴─────────────────────────┘
```
## parseDateTime64BestEffortUS
導入バージョン: v22.8.0
曖昧な場合に US 日付形式 (`MM/DD/YYYY` など) を優先する点を除き、[`parseDateTime64BestEffort`](#parseDateTime64BestEffort) と同じです。
**構文**
```sql theme={null}
parseDateTime64BestEffortUS(time_string [, precision [, time_zone]])
```
**引数**
* `time_string` — 変換対象の日付または日時を含む文字列。[`String`](/ja/reference/data-types/string)
* `precision` — 任意。必要な精度。ミリ秒は`3`、マイクロ秒は`6`。デフォルト: `3`。[`UInt8`](/ja/reference/data-types/int-uint)
* `time_zone` — 任意。タイムゾーン。関数はタイムゾーンに従って`time_string`を解析します。[`String`](/ja/reference/data-types/string)
**戻り値**
あいまいな場合は US 日付形式を優先して、`time_string`を[`DateTime64`](/ja/reference/data-types/datetime64)に変換して返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortUS('02/10/2025 12:30:45.123') AS us_format,
parseDateTime64BestEffortUS('15/08/2025 10:15:30.456') AS fallback_to_standard
```
```response title=Response theme={null}
┌─us_format───────────────┬─fallback_to_standard────┐
│ 2025-02-10 12:30:45.123 │ 2025-08-15 10:15:30.456 │
└─────────────────────────┴─────────────────────────┘
```
## parseDateTime64BestEffortUSOrNull
導入バージョン: v22.8.0
[`parseDateTime64BestEffort`](#parseDateTime64BestEffort) と同じですが、曖昧な場合には US 日付形式 (`MM/DD/YYYY` など) を優先し、処理できない日付形式に遭遇した場合は `NULL` を返します。
**Syntax**
```sql theme={null}
parseDateTime64BestEffortUSOrNull(time_string[, precision[, time_zone]])
```
**引数**
* `time_string` — 変換する日付または日時を含む String。 [`String`](/ja/reference/data-types/string)
* `precision` — 任意。必要な精度。`3` はミリ秒、`6` はマイクロ秒です。デフォルト: `3`。 [`UInt8`](/ja/reference/data-types/int-uint)
* `time_zone` — 任意。タイムゾーン。関数はこのタイムゾーンに従って `time_string` を解析します。 [`String`](/ja/reference/data-types/string)
**戻り値**
米国形式を優先して [`DateTime64`](/ja/reference/data-types/datetime64) に変換された `time_string` を返します。入力を解析できない場合は `NULL` を返します。 [`DateTime64`](/ja/reference/data-types/datetime64) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortUSOrNull('02/10/2025 12:30:45.123') AS valid_us,
parseDateTime64BestEffortUSOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────────┬─invalid─┐
│ 2025-02-10 12:30:45.123 │ ᴺᵁᴸᴸ │
└─────────────────────────┴─────────┘
```
## parseDateTime64BestEffortUSOrZero
導入バージョン: v22.8.0
[`parseDateTime64BestEffort`](#parseDateTime64BestEffort) と同様ですが、あいまいな場合は US 日付形式 (`MM/DD/YYYY` など) を優先し、処理できない日付形式に遭遇すると、ゼロ日付またはゼロの date time を返します。
**構文**
```sql theme={null}
parseDateTime64BestEffortUSOrZero(time_string [, precision [, time_zone]])
```
**引数**
* `time_string` — 変換する日付または日時を含む String。[`String`](/ja/reference/data-types/string)
* `precision` — 任意。必要な精度です。ミリ秒は `3`、マイクロ秒は `6`。デフォルト値: `3`。[`UInt8`](/ja/reference/data-types/int-uint)
* `time_zone` — 任意。タイムゾーン。関数は `time_string` をこのタイムゾーンに従って解析します。[`String`](/ja/reference/data-types/string)
**戻り値**
`time_string` を、米国形式を優先して [`DateTime64`](/ja/reference/data-types/datetime64) に変換して返します。入力を解析できない場合は、ゼロ日付/日時 (`1970-01-01 00:00:00.000`) を返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortUSOrZero('02/10/2025 12:30:45.123') AS valid_us,
parseDateTime64BestEffortUSOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────────┬─invalid─────────────────┐
│ 2025-02-10 12:30:45.123 │ 1970-01-01 00:00:00.000 │
└─────────────────────────┴─────────────────────────┘
```
## parseDateTime64InJodaSyntax
導入バージョン: v24.10.0
Joda の日付フォーマット文字列に従って、秒未満の精度を持つ日付と時刻の文字列を解析します。
この関数は、DateTime64 に対する [`formatDateTimeInJodaSyntax`](/ja/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax) の逆関数です。
Joda 形式のフォーマット String を使用して String 型の引数を解析します。戻り値は、1900 年から 2299 年までの日付を秒未満の精度で表現できる DateTime64 型です。
フォーマットパターンについては、[Joda Time documentation](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) を参照してください。
**構文**
```sql theme={null}
parseDateTime64InJodaSyntax(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime64 として解析する文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` をどのように解析するかを指定する Joda 構文のフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
Joda スタイルのフォーマット文字列に従って入力文字列を解析した DateTime64 を返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64InJodaSyntax('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')
```
```response title=Response theme={null}
┌─parseDateTime64InJodaSyntax('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')─┐
│ 2025-01-04 23:00:00.123 │
└────────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64InJodaSyntaxOrNull
導入バージョン: v24.10.0
[`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax) と同様ですが、解析できない日付形式に遭遇した場合は `NULL` を返します。
**構文**
```sql theme={null}
parseDateTime64InJodaSyntaxOrNull(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime64 にパースする対象の文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` をどのようにパースするかを指定する Joda 構文のフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
入力文字列をパースして得られた DateTime64 を返します。パースに失敗した場合は NULL を返します。[`Nullable(DateTime64)`](/ja/reference/data-types/nullable)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64InJodaSyntaxOrNull('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')
```
```response title=Response theme={null}
┌─parseDateTime64InJodaSyntaxOrNull('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')─┐
│ 2025-01-04 23:00:00.123 │
└──────────────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64InJodaSyntaxOrZero
導入バージョン: v24.10.0
[`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax) と同様ですが、解析できない日付形式に遭遇した場合はゼロ日付を返します。
**構文**
```sql theme={null}
parseDateTime64InJodaSyntaxOrZero(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime64 にパースする文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` をどのようにパースするかを指定する Joda 構文のフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
入力文字列からパースされた DateTime64 を返します。パースに失敗した場合はゼロの DateTime64 を返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64InJodaSyntaxOrZero('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')
```
```response title=Response theme={null}
┌─parseDateTime64InJodaSyntaxOrZero('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')─┐
│ 2025-01-04 23:00:00.123 │
└──────────────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64OrNull
導入バージョン: v24.11.0
[`parseDateTime64`](#parseDateTime64) と同様ですが、解析できない日付形式が指定された場合は `NULL` を返します。
**構文**
```sql theme={null}
parseDateTime64OrNull(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime64 にパースする対象の文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` をどのようにパースするかを指定するフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 省略可能。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
入力文字列からパースした DateTime64 を返します。パースに失敗した場合は NULL を返します。[`Nullable(DateTime64)`](/ja/reference/data-types/nullable)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64OrNull('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')
```
```response title=Response theme={null}
┌─parseDateTime64OrNull('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')─┐
│ 2025-01-04 23:00:00.123 │
└───────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64OrZero
導入バージョン: v24.11.0
[`parseDateTime64`](#parseDateTime64) と同様ですが、解釈できない日付フォーマットが指定された場合はゼロ日付を返します。
**構文**
```sql theme={null}
parseDateTime64OrZero(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime64 にパースされる文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` のパース方法を指定するフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
入力文字列をパースして得られた DateTime64 を返します。パースに失敗した場合は、ゼロの DateTime64 を返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTime64OrZero('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')
```
```response title=Response theme={null}
┌─parseDateTime64OrZero('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')─┐
│ 2025-01-04 23:00:00.123 │
└───────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeBestEffort
導入バージョン: v1.1.0
String 形式で表された日付と時刻を DateTime データ型に変換します。
この関数は、[ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html)、[RFC 1123 - 5.2.14 RFC-822](https://datatracker.ietf.org/doc/html/rfc822) の日付と時刻の仕様、ClickHouse 独自およびその他いくつかの日付・時刻フォーマットを解析します。
サポートされている非標準フォーマット:
* 9～10 桁の Unix タイムスタンプ を含む文字列。
* 日付と時刻の部分を含む文字列: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss` など。
* 日付は含むが、時刻の部分は含まない文字列: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` など。
* 日と時刻を含む文字列: `DD`, `DD hh`, `DD hh:mm`。この場合、`MM` は `01` に置き換えられます。
* 日付と時刻に加えてタイムゾーンのオフセット情報を含む文字列: `YYYY-MM-DD hh:mm:ss ±h:mm` など。
* syslog タイムスタンプ: `Mmm dd hh:mm:ss`。たとえば、`Jun 9 14:20:32`。
区切り文字を含むすべてのフォーマットで、この関数は月名のフルスペルまたは先頭 3 文字で表された月名を解析します。
年が指定されていない場合は、現在の年と見なされます。
**構文**
```sql theme={null}
parseDateTimeBestEffort(time_string[, time_zone])
```
**引数**
* `time_string` — 変換する日付と時刻を含む String。[`String`](/ja/reference/data-types/string)
* `time_zone` — 任意。`time_string` を解析する際に使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
`time_string` を `DateTime` として返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('23/10/2025 12:12:57') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-10-23 12:12:57 │
└─────────────────────────┘
```
**タイムゾーン指定あり**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('Sat, 18 Aug 2025 07:22:16 GMT', 'Asia/Istanbul') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-08-18 10:22:16 │
└─────────────────────────┘
```
**Unixタイムスタンプ**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('1735689600') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-01-01 00:00:00 │
└─────────────────────────┘
```
## parseDateTimeBestEffortOrNull
導入バージョン: v1.1.0
[`parseDateTimeBestEffort`](#parseDateTimeBestEffort) と同様ですが、処理できない日付フォーマットに遭遇した場合は `NULL` を返します。
この関数は、[ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)、[RFC 1123 - 5.2.14 RFC-822 Date and Time Specification](https://tools.ietf.org/html/rfc1123#page-55)、ClickHouse 独自のものを含む、いくつかの日付と時刻のフォーマットを解析します。
サポートされている非標準フォーマット:
* 9～10 桁の Unix タイムスタンプを含む文字列。
* 日付と時刻の部分を含む文字列: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss` など。
* 日付は含むが、時刻の部分を含まない文字列: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` など。
* 日と時刻を含む文字列: `DD`, `DD hh`, `DD hh:mm`。この場合、`MM` は `01` に置き換えられます。
* 日付と時刻に加えて、タイムゾーンオフセット情報を含む文字列: `YYYY-MM-DD hh:mm:ss ±h:mm` など。
* syslog のタイムスタンプ: `Mmm dd hh:mm:ss`。たとえば `Jun 9 14:20:32`。
区切り文字を含むすべてのフォーマットで、この関数は月名のフルスペルまたは先頭 3 文字で表記された月名を解析します。
年が指定されていない場合は、現在の年と見なされます。
**構文**
```sql theme={null}
parseDateTimeBestEffortOrNull(time_string[, time_zone])
```
**引数**
* `time_string` — 変換する日付と時刻を表す String。[`String`](/ja/reference/data-types/string)
* `time_zone` — 任意。`time_string` の解析に使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
`time_string` を DateTime として返します。入力を解析できない場合は `NULL` を返します。[`DateTime`](/ja/reference/data-types/datetime) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortOrNull('23/10/2025 12:12:57') AS valid,
parseDateTimeBestEffortOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─┐
│ 2025-10-23 12:12:57 │ ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```
## parseDateTimeBestEffortOrZero
導入バージョン: v1.1.0
処理できない日付フォーマットを検出した場合に、ゼロ日付またはゼロ日時を返す点を除き、[`parseDateTimeBestEffort`](#parseDateTimeBestEffort) と同じです。
この関数は、[ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)、[RFC 1123 - 5.2.14 RFC-822 Date and Time Specification](https://tools.ietf.org/html/rfc1123#page-55)、ClickHouse およびその他いくつかの日付と時刻のフォーマットを解析します。
サポートされる非標準フォーマット:
* 9～10 桁の Unix タイムスタンプ を含む文字列。
* 日付と時刻の部分を含む文字列: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss` など。
* 日付は含むが時刻の部分がない文字列: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` など。
* 日と時刻を含む文字列: `DD`, `DD hh`, `DD hh:mm`。この場合、`MM` は `01` に置き換えられます。
* 日付と時刻に加えて time zone オフセット情報を含む文字列: `YYYY-MM-DD hh:mm:ss ±h:mm` など。
* syslog の timestamp: `Mmm dd hh:mm:ss`。たとえば `Jun 9 14:20:32`。
区切り文字を含むすべてのフォーマットについて、この関数は月名のフルスペル、または先頭 3 文字で表された月名を解析します。
年が指定されていない場合は、現在の年として扱われます。
**構文**
```sql theme={null}
parseDateTimeBestEffortOrZero(time_string[, time_zone])
```
**引数**
* `time_string` — 変換する日付と時刻を含む文字列。[`String`](/ja/reference/data-types/string)
* `time_zone` — 任意。`time_string` の解析に使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
`time_string` を `DateTime` として返します。入力を解析できない場合は、ゼロ日付/日時 (`1970-01-01` または `1970-01-01 00:00:00`) を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortOrZero('23/10/2025 12:12:57') AS valid,
parseDateTimeBestEffortOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─────────────┐
│ 2025-10-23 12:12:57 │ 1970-01-01 00:00:00 │
└─────────────────────┴─────────────────────┘
```
## parseDateTimeBestEffortUS
導入バージョン: v1.1.0
この関数は、ISO 日付フォーマット (例: `YYYY-MM-DD hh:mm:ss`) や、月と日の部分を曖昧さなく判別できるその他の日付フォーマット (例: `YYYYMMDDhhmmss`、`YYYY-MM`、`DD hh`、`YYYY-MM-DD hh:mm:ss ±h:mm`) については、[`parseDateTimeBestEffort`](#parseDateTimeBestEffort) と同様に動作します。
月と日の部分を曖昧さなく判別できない場合 (例: `MM/DD/YYYY`、`MM-DD-YYYY`、`MM-DD-YY`) は、`DD/MM/YYYY`、`DD-MM-YYYY`、`DD-MM-YY` ではなく、US 日付形式を優先します。
ただし、前述の説明の例外として、月が 12 より大きく 31 以下の場合、この関数は [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) の動作にフォールバックします。たとえば `15/08/2020` は `2020-08-15` として解析されます。
**構文**
```sql theme={null}
parseDateTimeBestEffortUS(time_string[, time_zone])
```
**引数**
* `time_string` — 変換する日付と時刻を含む文字列。[`String`](/ja/reference/data-types/string)
* `time_zone` — 任意。`time_string` の解析時に使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
曖昧な場合は US 日付形式を優先し、`time_string` を `DateTime` として返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortUS('02/10/2025') AS us_format,
parseDateTimeBestEffortUS('15/08/2025') AS fallback_to_standard
```
```response title=Response theme={null}
┌─us_format───────────┬─fallback_to_standard─┐
│ 2025-02-10 00:00:00 │ 2025-08-15 00:00:00 │
└─────────────────────┴──────────────────────┘
```
## parseDateTimeBestEffortUSOrNull
導入バージョン: v1.1.0
処理できない日付フォーマットに遭遇した場合に `NULL` を返す点を除き、[`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS) 関数と同じです。
この関数は ISO 日付フォーマットに対しては [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) と同様に動作しますが、曖昧なケースでは US 日付形式を優先し、パースエラーが発生した場合は `NULL` を返します。
**構文**
```sql theme={null}
parseDateTimeBestEffortUSOrNull(time_string[, time_zone])
```
**引数**
* `time_string` — 変換する日付と時刻を含む文字列。[`String`](/ja/reference/data-types/string)
* `time_zone` — 任意。`time_string` をパースする際に使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
`time_string` を US 形式優先で DateTime として返します。入力をパースできない場合は `NULL` を返します。[`DateTime`](/ja/reference/data-types/datetime) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortUSOrNull('02/10/2025') AS valid_us,
parseDateTimeBestEffortUSOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────┬─invalid─┐
│ 2025-02-10 00:00:00 │ ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```
## parseDateTimeBestEffortUSOrZero
導入バージョン: v1.1.0
[`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS) 関数と同様ですが、処理できない日付フォーマットに遭遇した場合は、ゼロ日付 (`1970-01-01`) または日時のゼロ日付 (`1970-01-01 00:00:00`) を返します。
この関数は ISO 日付フォーマットに対しては [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) と同様に動作しますが、曖昧なケースでは US 日付形式を優先し、パースエラー時にはゼロを返します。
**構文**
```sql theme={null}
parseDateTimeBestEffortUSOrZero(time_string[, time_zone])
```
**引数**
* `time_string` — 変換する日付と時刻を含む String。[`String`](/ja/reference/data-types/string)
* `time_zone` — 任意。`time_string` を解析する際に使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
US 形式を優先して、`time_string` を `DateTime` として返します。入力を解析できない場合は、ゼロ日付/日時 (`1970-01-01` または `1970-01-01 00:00:00`) を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortUSOrZero('02/10/2025') AS valid_us,
parseDateTimeBestEffortUSOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────┬─invalid─────────────┐
│ 2025-02-10 00:00:00 │ 1970-01-01 00:00:00 │
└─────────────────────┴─────────────────────┘
```
## parseDateTimeInJodaSyntax
導入バージョン: v23.3.0
Joda の日付フォーマット文字列に従って、日付と時刻の文字列を解析します。
この関数は [`formatDateTimeInJodaSyntax`](/ja/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax) の逆関数です。
Joda スタイルのフォーマット String を使用して String 型の argument を解析します。戻り値は DateTime 型です。
フォーマットパターンについては、[Joda Time documentation](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) を参照してください。
**構文**
```sql theme={null}
parseDateTimeInJodaSyntax(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime に解析される文字列。 [`String`](/ja/reference/data-types/string)
* `format` — `time_string` をどのように解析するかを指定する Joda 構文のフォーマット文字列。 [`String`](/ja/reference/data-types/string)
* `timezone` — 任意。タイムゾーン。 [`String`](/ja/reference/data-types/string)
**戻り値**
Joda スタイルのフォーマット文字列に従って入力文字列から解析された DateTime を返します。 [`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeInJodaSyntax('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─parseDateTimeInJodaSyntax('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')─┐
│ 2025-01-04 23:00:00 │
└──────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeInJodaSyntaxOrNull
導入バージョン: v23.3.0
[`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax) と同じですが、解析不能な日付フォーマットに遭遇した場合は `NULL` を返します。
**構文**
```sql theme={null}
parseDateTimeInJodaSyntaxOrNull(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime にパースされる文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` のパース方法を指定する、Joda 構文のフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
入力文字列からパースされた DateTime を返します。パースに失敗した場合は NULL を返します。[`Nullable(DateTime)`](/ja/reference/data-types/nullable)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeInJodaSyntaxOrNull('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─parseDateTimeInJodaSyntaxOrNull('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')─┐
│ 2025-01-04 23:00:00 │
└────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeInJodaSyntaxOrZero
導入バージョン: v23.3.0
[`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax) と同じですが、解析できない日付形式が指定された場合はゼロ日付を返します。
**構文**
```sql theme={null}
parseDateTimeInJodaSyntaxOrZero(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime にパースする文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` のパース方法を指定する、Joda 構文 の format string。[`String`](/ja/reference/data-types/string)
* `timezone` — 省略可能。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
入力文字列からパースされた DateTime を返します。パースに失敗した場合はゼロ DateTime を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeInJodaSyntaxOrZero('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─parseDateTimeInJodaSyntaxOrZero('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')─┐
│ 2025-01-04 23:00:00 │
└────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeOrNull
導入バージョン: v23.3.0
[`parseDateTime`](#parseDateTime) と同様ですが、解釈できない日付形式の場合は `NULL` を返します。
**構文**
```sql theme={null}
parseDateTimeOrNull(time_string, format[, timezone])
```
**別名**: `str_to_date`
**引数**
* `time_string` — DateTime にパースする対象の文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` をどのようにパースするかを指定するフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
入力文字列をパースして得られた DateTime を返します。パースに失敗した場合は NULL を返します。[`Nullable(DateTime)`](/ja/reference/data-types/nullable)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeOrNull('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
```
```response title=Response theme={null}
┌─parseDateTimeOrNull('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2025-01-04 23:00:00 │
└─────────────────────────────────────────────────────────────────┘
```
## parseDateTimeOrZero
導入バージョン: v23.3.0
[`parseDateTime`](#parseDateTime) と同様ですが、パースできない日付形式に遭遇した場合はゼロ日付を返します。
**構文**
```sql theme={null}
parseDateTimeOrZero(time_string, format[, timezone])
```
**引数**
* `time_string` — DateTime にパースする文字列。[`String`](/ja/reference/data-types/string)
* `format` — `time_string` をどのようにパースするかを指定するフォーマット文字列。[`String`](/ja/reference/data-types/string)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
入力文字列からパースされた DateTime を返します。パースに失敗した場合は、ゼロ値の DateTime を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT parseDateTimeOrZero('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
```
```response title=Response theme={null}
┌─parseDateTimeOrZero('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2025-01-04 23:00:00 │
└─────────────────────────────────────────────────────────────────┘
```
## reinterpret
導入バージョン: v1.1.0
指定された値 `x` のメモリ上のバイト列をそのまま使用し、宛先の型として再解釈します。
**構文**
```sql theme={null}
reinterpret(x, type)
```
**引数**
* `x` — 任意の型。[`Any`](/ja/reference/data-types/index)
* `type` — 変換先の型。配列の場合、配列の要素型は固定長型である必要があります。[`String`](/ja/reference/data-types/string)
**戻り値**
変換先の型の値。[`Any`](/ja/reference/data-types/index)
**例**
**使用例**
```sql title=Query theme={null}
SELECT reinterpret(toInt8(-1), 'UInt8') AS int_to_uint,
reinterpret(toInt8(1), 'Float32') AS int_to_float,
reinterpret('1', 'UInt32') AS string_to_int
```
```response title=Response theme={null}
┌─int_to_uint─┬─int_to_float─┬─string_to_int─┐
│ 255 │ 1e-45 │ 49 │
└─────────────┴──────────────┴───────────────┘
```
**Array の例**
```sql title=Query theme={null}
SELECT reinterpret(x'3108b4403108d4403108b4403108d440', 'Array(Float32)') AS string_to_array_of_Float32
```
```response title=Response theme={null}
┌─string_to_array_of_Float32─┐
│ [5.626,6.626,5.626,6.626] │
└────────────────────────────┘
```
## reinterpretAsDate
導入バージョン: v1.1.0
入力値を Date 型の値として再解釈します (リトルエンディアン順を前提) 。これは、Unix エポック 1970-01-01 の開始からの日数を表します
**構文**
```sql theme={null}
reinterpretAsDate(x)
```
**引数**
* `x` — Unixエポックの開始以降の日数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
Date。[`Date`](/ja/reference/data-types/date)
**例**
**使用例**
```sql title=Query theme={null}
SELECT reinterpretAsDate(65), reinterpretAsDate('A')
```
```response title=Response theme={null}
┌─reinterpretAsDate(65)─┬─reinterpretAsDate('A')─┐
│ 1970-03-07 │ 1970-03-07 │
└───────────────────────┴────────────────────────┘
```
## reinterpretAsDateTime
導入バージョン: v1.1.0
入力値を DateTime 値として再解釈します (リトルエンディアン順を前提) 。この値は Unix エポック 1970-01-01 の開始からの日数を表します。
**構文**
```sql theme={null}
reinterpretAsDateTime(x)
```
**引数**
* `x` — Unixエポックの開始からの秒数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
日付と時刻。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT reinterpretAsDateTime(65), reinterpretAsDateTime('A')
```
```response title=Response theme={null}
┌─reinterpretAsDateTime(65)─┬─reinterpretAsDateTime('A')─┐
│ 1970-01-01 01:01:05 │ 1970-01-01 01:01:05 │
└───────────────────────────┴────────────────────────────┘
```
## reinterpretAsFixedString
導入バージョン: v1.1.0
入力値を固定長文字列として再解釈します (リトルエンディアン順であると仮定します) 。
末尾のヌルバイトは無視されます。たとえば、UInt32 の値 255 に対して、この関数は 1 文字の文字列を返します。
**構文**
```sql theme={null}
reinterpretAsFixedString(x)
```
**引数**
* `x` — 文字列に再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime)
**戻り値**
`x` を表すバイトを含む固定長文字列。[`FixedString`](/ja/reference/data-types/fixedstring)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
reinterpretAsFixedString(toDateTime('1970-01-01 01:01:05')),
reinterpretAsFixedString(toDate('1970-03-07'))
```
```response title=Response theme={null}
┌─reinterpretAsFixedString(toDateTime('1970-01-01 01:01:05'))─┬─reinterpretAsFixedString(toDate('1970-03-07'))─┐
│ A │ A │
└─────────────────────────────────────────────────────────────┴────────────────────────────────────────────────┘
```
## reinterpretAsFloat32
導入バージョン: v1.1.0
入力値を Float32 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表現できない場合、結果は未定義です。
**構文**
```sql theme={null}
reinterpretAsFloat32(x)
```
**引数**
* `x` — `Float32` として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
`x` を再解釈した値を返します。[`Float32`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT reinterpretAsUInt32(toFloat32(0.2)) AS x, reinterpretAsFloat32(x)
```
```response title=Response theme={null}
┌──────────x─┬─reinterpretAsFloat32(x)─┐
│ 1045220557 │ 0.2 │
└────────────┴─────────────────────────┘
```
## reinterpretAsFloat64
導入バージョン: v1.1.0
入力値をFloat64型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表現できない場合、出力は未定義です。
**構文**
```sql theme={null}
reinterpretAsFloat64(x)
```
**引数**
* `x` — `Float64` として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈された値 `x` を返します。[`Float64`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT reinterpretAsUInt64(toFloat64(0.2)) AS x, reinterpretAsFloat64(x)
```
```response title=Response theme={null}
┌───────────────────x─┬─reinterpretAsFloat64(x)─┐
│ 4596373779694328218 │ 0.2 │
└─────────────────────┴─────────────────────────┘
```
## reinterpretAsInt128
導入バージョン: v1.1.0
入力値を Int128 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表せない場合、結果は未定義です。
**構文**
```sql theme={null}
reinterpretAsInt128(x)
```
**引数**
* `x` — `Int128` として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈された値 `x` を返します。[`Int128`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt64(257) AS x,
toTypeName(x),
reinterpretAsInt128(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int64 │ 257 │ Int128 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt16
導入バージョン: v1.1.0
入力値を Int16 型として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表現できない場合、出力は未定義になります。
**構文**
```sql theme={null}
reinterpretAsInt16(x)
```
**引数**
* `x` — Int16 として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈された値 `x` を返します。[`Int16`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt8(257) AS x,
toTypeName(x),
reinterpretAsInt16(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ Int8 │ 1 │ Int16 │
└───┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt256
導入バージョン: v1.1.0
入力値を Int256 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。対象の型で入力型を表現できない場合、出力は未定義になります。
**構文**
```sql theme={null}
reinterpretAsInt256(x)
```
**引数**
* `x` — `Int256` として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈された `x` の値を返します。[`Int256`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt128(257) AS x,
toTypeName(x),
reinterpretAsInt256(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int128 │ 257 │ Int256 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt32
導入バージョン: v1.1.0
入力値を Int32 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。対象の型で入力型を表現できない場合、結果は未定義です。
**構文**
```sql theme={null}
reinterpretAsInt32(x)
```
**引数**
* `x` — `Int32` として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈された `x` の値を返します。[`Int32`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt16(257) AS x,
toTypeName(x),
reinterpretAsInt32(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int16 │ 257 │ Int32 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt64
導入バージョン: v1.1.0
入力値を Int64 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表現できない場合、出力は未定義です。
**構文**
```sql theme={null}
reinterpretAsInt64(x)
```
**引数**
* `x` — Int64 として再解釈する対象の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈した値 `x` を返します。[`Int64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt32(257) AS x,
toTypeName(x),
reinterpretAsInt64(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int32 │ 257 │ Int64 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt8
導入バージョン: v1.1.0
入力値を Int8 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表現できない場合、出力は未定義です。
**構文**
```sql theme={null}
reinterpretAsInt8(x)
```
**引数**
* `x` — `Int8` として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈された値 `x` を返します。[`Int8`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt8(257) AS x,
toTypeName(x),
reinterpretAsInt8(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ UInt8 │ 1 │ Int8 │
└───┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsString
導入バージョン: v1.1.0
入力値を文字列として再解釈します (リトルエンディアン順を前提とします) 。
末尾のヌルバイトは無視されます。たとえば、UInt32 型の値 255 に対しては、1 文字の文字列を返します。
**構文**
```sql theme={null}
reinterpretAsString(x)
```
**引数**
* `x` — 文字列として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime)
**戻り値**
`x` を表すバイト列を含む文字列。[`String`](/ja/reference/data-types/string)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
reinterpretAsString(toDateTime('1970-01-01 01:01:05')),
reinterpretAsString(toDate('1970-03-07'))
```
```response title=Response theme={null}
┌─reinterpretAsString(toDateTime('1970-01-01 01:01:05'))─┬─reinterpretAsString(toDate('1970-03-07'))─┐
│ A │ A │
└────────────────────────────────────────────────────────┴───────────────────────────────────────────┘
```
## reinterpretAsUInt128
導入バージョン: v1.1.0
入力値をUInt128型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表現できない場合、出力は未定義です。
**構文**
```sql theme={null}
reinterpretAsUInt128(x)
```
**引数**
* `x` — `UInt128` として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈後の値 `x` を返します。[`UInt128`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt64(257) AS x,
toTypeName(x),
reinterpretAsUInt128(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt64 │ 257 │ UInt128 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt16
導入バージョン: v1.1.0
入力値を UInt16 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表現できない場合、出力は未定義です。
**構文**
```sql theme={null}
reinterpretAsUInt16(x)
```
**引数**
* `x` — UInt16 として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈された値 `x` を返します。[`UInt16`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt8(257) AS x,
toTypeName(x),
reinterpretAsUInt16(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ UInt8 │ 1 │ UInt16 │
└───┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt256
導入バージョン: v1.1.0
入力値を UInt256 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。対象の型で入力型を表現できない場合、出力は未定義です。
**構文**
```sql theme={null}
reinterpretAsUInt256(x)
```
**引数**
* `x` — UInt256 として再解釈する対象の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈後の値 `x` を返します。[`UInt256`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt128(257) AS x,
toTypeName(x),
reinterpretAsUInt256(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt128 │ 257 │ UInt256 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt32
導入バージョン: v1.1.0
入力値を UInt32 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表現できない場合、出力は未定義です。
**構文**
```sql theme={null}
reinterpretAsUInt32(x)
```
**引数**
* `x` — UInt32 として再解釈する対象の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈された値 `x` を返します。[`UInt32`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt16(257) AS x,
toTypeName(x),
reinterpretAsUInt32(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt16 │ 257 │ UInt32 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt64
導入バージョン: v1.1.0
入力値を UInt64 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力型を表現できない場合、出力は未定義です。
**構文**
```sql theme={null}
reinterpretAsUInt64(x)
```
**引数**
* `x` — UInt64 として再解釈される値。[`Int*`](/ja/reference/data-types/int-uint) または [`UInt*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
`x` を再解釈した値を返します。[`UInt64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt32(257) AS x,
toTypeName(x),
reinterpretAsUInt64(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt32 │ 257 │ UInt64 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt8
導入バージョン: v1.1.0
入力値を UInt8 型の値として再解釈します。
[`CAST`](#CAST) とは異なり、この関数は元の値を保持しようとはしません。変換先の型で入力値を表現できない場合、出力は未定義です。
**構文**
```sql theme={null}
reinterpretAsUInt8(x)
```
**引数**
* `x` — `UInt8` として再解釈する値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`UUID`](/ja/reference/data-types/uuid) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
再解釈後の値 `x` を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt8(-1) AS val,
toTypeName(val),
reinterpretAsUInt8(val) AS res,
toTypeName(res);
```
```response title=Response theme={null}
┌─val─┬─toTypeName(val)─┬─res─┬─toTypeName(res)─┐
│ -1 │ Int8 │ 255 │ UInt8 │
└─────┴─────────────────┴─────┴─────────────────┘
```
## reinterpretAsUUID
導入バージョン: v1.1.0
16バイトの文字列を受け取り、各8バイトの半分をリトルエンディアンのバイト順として解釈し、UUID を返します。文字列の長さが足りない場合、この関数は末尾に必要な数の null byte が追加されたものとして動作します。文字列が16バイトを超える場合、末尾の余分なバイトは無視されます。
**構文**
```sql theme={null}
reinterpretAsUUID(fixed_string)
```
**引数**
* `fixed_string` — ビッグエンディアン形式のバイト列。[`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
UUID 型の値。[`UUID`](/ja/reference/data-types/uuid)
**例**
**文字列から UUID**
```sql title=Query theme={null}
SELECT reinterpretAsUUID(reverse(unhex('000102030405060708090a0b0c0d0e0f')))
```
```response title=Response theme={null}
┌─reinterpretAsUUID(reverse(unhex('000102030405060708090a0b0c0d0e0f')))─┐
│ 08090a0b-0c0d-0e0f-0001-020304050607 │
└───────────────────────────────────────────────────────────────────────┘
```
## toBFloat16
導入バージョン: v1.1.0
入力値を BFloat16 型の値に変換します。
エラーが発生した場合は例外をスローします。
関連項目:
* [`toBFloat16OrZero`](#toBFloat16OrZero)。
* [`toBFloat16OrNull`](#toBFloat16OrNull)。
**構文**
```sql theme={null}
toBFloat16(expr)
```
**引数**
* `expr` — 数値またはその文字列表現を返す式。 [`Expression`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
16ビットの brain-float 値を返します。 [`BFloat16`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toBFloat16(toFloat32(42.7)),
toBFloat16(toFloat32('42.7')),
toBFloat16('42.7')
FORMAT Vertical;
```
```response title=Response theme={null}
toBFloat16(toFloat32(42.7)): 42.5
toBFloat16(t⋯32('42.7')): 42.5
toBFloat16('42.7'): 42.5
```
## toBFloat16OrNull
導入バージョン: v1.1.0
String 型の入力値を BFloat16 型の値に変換します。
文字列が浮動小数点数値を表していない場合、この関数は NULL を返します。
サポートされる引数:
* 数値を表す文字列。
サポートされない引数 (`NULL` を返します):
* バイナリ値および16進値を表す文字列。
* 数値。
この関数では、文字列表現から変換する際に精度が失われることがありますが、その際にエラーは返されません。
関連項目:
* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrZero`](#toBFloat16OrZero).
**構文**
```sql theme={null}
toBFloat16OrNull(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
16 ビットの brain-float 値を返します。変換できない場合は `NULL` を返します。[`BFloat16`](/ja/reference/data-types/float) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toBFloat16OrNull('0x5E'), -- サポート対象外の引数
toBFloat16OrNull('12.3'), -- 一般的な使用例
toBFloat16OrNull('12.3456789') -- 精度が失われても通知されない
```
```response title=Response theme={null}
\N
12.25
12.3125
```
## toBFloat16OrZero
導入バージョン: v1.1.0
String 型の入力値を BFloat16 型の値に変換します。
文字列が浮動小数点数を表していない場合、この関数はゼロを返します。
サポートされる引数:
* 数値を表す文字列。
サポートされない引数 (`0` を返します):
* バイナリ値および 16 進数値を表す文字列。
* 数値。
この関数では、文字列表現から変換する際に、精度が失われてもエラーになりません。
関連項目:
* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrNull`](#toBFloat16OrNull).
**構文**
```sql theme={null}
toBFloat16OrZero(x)
```
**引数**
* `x` — 数値の文字列表現。 [`String`](/ja/reference/data-types/string)
**戻り値**
16 ビットの brain-float 値を返します。そうでない場合は `0` を返します。 [`BFloat16`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toBFloat16OrZero('0x5E'), -- サポート対象外の引数
toBFloat16OrZero('12.3'), -- 一般的な使用例
toBFloat16OrZero('12.3456789') -- 精度が暗黙的に失われる
```
```response title=Response theme={null}
0
12.25
12.3125
```
## toBool
導入バージョン: v22.2.0
入力値を Bool 型の値に変換します。
**構文**
```sql theme={null}
toBool(expr)
```
**引数**
* `expr` — 数値または文字列を返す式。文字列の場合は、'true' または 'false' を受け付けます (大文字と小文字は区別されません) 。 [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string) または [`Expression`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
引数の評価結果に応じて `true` または `false` を返します。 [`Bool`](/ja/reference/data-types/boolean)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toBool(toUInt8(1)),
toBool(toInt8(-1)),
toBool(toFloat32(1.01)),
toBool('true'),
toBool('false'),
toBool('FALSE')
FORMAT Vertical
```
```response title=Response theme={null}
toBool(toUInt8(1)): true
toBool(toInt8(-1)): true
toBool(toFloat32(1.01)): true
toBool('true'): true
toBool('false'): false
toBool('FALSE'): false
```
## toDate
導入バージョン: v1.1.0
入力値を [`Date`](/ja/reference/data-types/date) 型に変換します。
String、FixedString、DateTime、または数値型から変換できます。
**構文**
```sql theme={null}
toDate(x)
```
**引数**
* `x` — 変換対象の入力値。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`DateTime`](/ja/reference/data-types/datetime) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
**戻り値**
変換後の入力値を返します。[`Date`](/ja/reference/data-types/date)
**例**
**String から Date への変換**
```sql title=Query theme={null}
SELECT toDate('2025-04-15')
```
```response title=Response theme={null}
2025-04-15
```
**DateTimeをDateに変換**
```sql title=Query theme={null}
SELECT toDate(toDateTime('2025-04-15 10:30:00'))
```
```response title=Response theme={null}
2025-04-15
```
**整数をDateに変換**
```sql title=Query theme={null}
SELECT toDate(20297)
```
```response title=Response theme={null}
2025-07-28
```
## toDate32
導入バージョン: v21.9.0
引数を [Date32](/ja/reference/data-types/date32) データ型に変換します。
値が範囲外の場合、`toDate32` は [Date32](/ja/reference/data-types/date32) でサポートされる境界値を返します。
引数の型が [`Date`](/ja/reference/data-types/date) の場合は、その範囲が考慮されます。
**構文**
```sql theme={null}
toDate32(expr)
```
**引数**
* `expr` — 変換対象の値。[`String`](/ja/reference/data-types/string) または [`UInt32`](/ja/reference/data-types/int-uint) または [`Date`](/ja/reference/data-types/date)
**戻り値**
日付を返します。[`Date32`](/ja/reference/data-types/date32)
**例**
**範囲内**
```sql title=Query theme={null}
SELECT toDate32('2025-01-01') AS value, toTypeName(value)
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
value: 2025-01-01
toTypeName(value): Date32
```
**範囲外**
```sql title=Query theme={null}
SELECT toDate32('1899-01-01') AS value, toTypeName(value)
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
value: 1900-01-01
toTypeName(value): Date32
```
## toDate32OrDefault
導入バージョン: v21.11.0
引数を [Date32](/ja/reference/data-types/date32) 型に変換します。値が範囲外の場合、`toDate32OrDefault` は [Date32](/ja/reference/data-types/date32) でサポートされている下限値を返します。引数が [Date](/ja/reference/data-types/date) 型の場合は、その型の範囲が考慮されます。無効な引数を受け取った場合は、デフォルト値を返します。
**構文**
```sql theme={null}
toDate32OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string)、[`(U)Int*`](/ja/reference/data-types/int-uint)、または [`Float*`](/ja/reference/data-types/float)
* `default` — 省略可能。パースに失敗した場合に返されるデフォルト値。[`Date32`](/ja/reference/data-types/date32)
**戻り値**
成功した場合は Date32 型の値を返します。失敗した場合は、`default` が指定されていればその値を、指定されていなければ 1900-01-01 を返します。[`Date32`](/ja/reference/data-types/date32)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toDate32OrDefault('1930-01-01', toDate32('2020-01-01'))
```
```response title=Response theme={null}
1930-01-01
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toDate32OrDefault('xx1930-01-01', toDate32('2020-01-01'))
```
```response title=Response theme={null}
2020-01-01
```
## toDate32OrNull
導入バージョン: v21.9.0
入力値を Date32 型の値に変換しますが、無効な引数が渡された場合は `NULL` を返します。
[`toDate32`](#toDate32) と同じですが、無効な引数が渡された場合は `NULL` を返します。
**構文**
```sql theme={null}
toDate32OrNull(x)
```
**引数**
* `x` — 日付の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は `Date32` 値を返し、失敗した場合は `NULL` を返します。[`Date32`](/ja/reference/data-types/date32) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDate32OrNull('2025-01-01'), toDate32OrNull('invalid')
```
```response title=Response theme={null}
┌─toDate32OrNull('2025-01-01')─┬─toDate32OrNull('invalid')─┐
│ 2025-01-01 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴───────────────────────────┘
```
## toDate32OrZero
導入バージョン: v21.9.0
入力値を [Date32](/ja/reference/data-types/date32) 型の値に変換します。無効な引数を受け取った場合は、[Date32](/ja/reference/data-types/date32) の下限値を返します。
[toDate32](#toDate32) と同様ですが、無効な引数を受け取った場合は [Date32](/ja/reference/data-types/date32) の下限値を返します。
関連項目:
* [`toDate32`](#toDate32)
* [`toDate32OrNull`](#toDate32OrNull)
* [`toDate32OrDefault`](#toDate32OrDefault)
**構文**
```sql theme={null}
toDate32OrZero(x)
```
**引数**
* `x` — 日付の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は Date32 値を返し、失敗した場合は Date32 の下限値 (`1900-01-01`) を返します。[`Date32`](/ja/reference/data-types/date32)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDate32OrZero('2025-01-01'), toDate32OrZero('')
```
```response title=Response theme={null}
┌─toDate32OrZero('2025-01-01')─┬─toDate32OrZero('')─┐
│ 2025-01-01 │ 1900-01-01 │
└──────────────────────────────┴────────────────────┘
```
## toDateOrDefault
導入バージョン: v21.11.0
[toDate](#toDate) と同様ですが、変換に失敗した場合はデフォルト値を返します。デフォルト値には、第2引数が指定されている場合はその値が、指定されていない場合は [Date](/ja/reference/data-types/date) の下限値が使用されます。
**構文**
```sql theme={null}
toDateOrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 省略可能。パースに失敗した場合に返されるデフォルト値。[`Date`](/ja/reference/data-types/date)
**戻り値**
成功した場合は Date 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 1970-01-01 を返します。[`Date`](/ja/reference/data-types/date)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toDateOrDefault('2022-12-30')
```
```response title=Response theme={null}
2022-12-30
```
**変換に失敗**
```sql title=Query theme={null}
SELECT toDateOrDefault('', CAST('2023-01-01', 'Date'))
```
```response title=Response theme={null}
2023-01-01
```
## toDateOrNull
導入バージョン: v1.1.0
入力値を `Date` 型の値に変換しますが、無効な引数が渡された場合は `NULL` を返します。
[`toDate`](#toDate) と同様ですが、無効な引数が渡された場合は `NULL` を返します。
**構文**
```sql theme={null}
toDateOrNull(x)
```
**引数**
* `x` — 日付の文字列表現です。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は `Date` 値を返し、失敗した場合は `NULL` を返します。[`Date`](/ja/reference/data-types/date) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDateOrNull('2025-12-30'), toDateOrNull('invalid')
```
```response title=Response theme={null}
┌─toDateOrNull('2025-12-30')─┬─toDateOrNull('invalid')─┐
│ 2025-12-30 │ ᴺᵁᴸᴸ │
└────────────────────────────┴────────────────────────┘
```
## toDateOrZero
導入バージョン: v1.1.0
入力値を [`Date`](/ja/reference/data-types/date) 型の値に変換します。無効な引数を受け取った場合は、[`Date`](/ja/reference/data-types/date) の下限値を返します。
[toDate](#toDate) と同様ですが、無効な引数を受け取った場合は [`Date`](/ja/reference/data-types/date) の下限値を返します。
関連項目:
* [`toDate`](#toDate)
* [`toDateOrNull`](#toDateOrNull)
* [`toDateOrDefault`](#toDateOrDefault)
**構文**
```sql theme={null}
toDateOrZero(x)
```
**引数**
* `x` — 日付の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は Date 値を、失敗した場合は Date の下限値 (`1970-01-01`) を返します。[`Date`](/ja/reference/data-types/date)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDateOrZero('2025-12-30'), toDateOrZero('')
```
```response title=Response theme={null}
┌─toDateOrZero('2025-12-30')─┬─toDateOrZero('')─┐
│ 2025-12-30 │ 1970-01-01 │
└────────────────────────────┴──────────────────┘
```
## toDateTime
導入バージョン: v1.1.0
入力値を [DateTime](/ja/reference/data-types/datetime) 型に変換します。
`expr` が数値の場合、Unix epoch の開始からの経過秒数 (Unix timestamp) として解釈されます。
`expr` が [String](/ja/reference/data-types/string) の場合、Unix timestamp、または date / 日時の文字列表現として解釈されることがあります。
そのため、短い数値文字列 (4 桁以下) のパースは、曖昧さを避けるため明示的に無効化されています。たとえば、文字列 `'1999'` は年 (Date / DateTime の不完全な文字列表現) を表す場合も、unix timestamp を表す場合もあります。より長い数値文字列は使用できます。
**構文**
```sql theme={null}
toDateTime(expr[, time_zone])
```
**引数**
* `expr` — 値。[`String`](/ja/reference/data-types/string) または [`Int`](/ja/reference/data-types/int-uint) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime)
* `time_zone` — タイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
日時を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDateTime('2025-01-01 00:00:00'), toDateTime(1735689600, 'UTC')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toDateTime('2025-01-01 00:00:00'): 2025-01-01 00:00:00
toDateTime(1735689600, 'UTC'): 2025-01-01 00:00:00
```
## toDateTime32
導入バージョン: v20.9.0
入力値を `DateTime` 型に変換します。
`String`、`FixedString`、`Date`、`Date32`、`DateTime`、または数値型 (`(U)Int*`、`Float*`、`Decimal`) からの変換をサポートします。
DateTime32 は `DateTime` より広い範囲を扱え、`1900-01-01` から `2299-12-31` までの日付をサポートします。
**構文**
```sql theme={null}
toDateTime32(x[, timezone])
```
**引数**
* `x` — 変換する入力値。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`UInt*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`DateTime64`](/ja/reference/data-types/datetime64)
* `timezone` — 省略可能。返される `DateTime` 値に使用するタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
変換された入力値を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**値が範囲内にある場合**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00.000', 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('20255-01-01 00:00:00.000', 3))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────────────────┘
```
**精度付きの Decimal として**
```sql title=Query theme={null}
SELECT toDateTime64(1735689600.000, 3) AS value, toTypeName(value);
-- 小数点がない場合でも、この値は引き続き秒単位の Unix timestamp として扱われます
SELECT toDateTime64(1546300800000, 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64(1735689600.000, 3))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴──────────────────────────────────────────┘
┌───────────────────value─┬─toTypeName(toDateTime64(1546300800000, 3))─┐
│ 2282-12-31 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────┘
```
**タイムゾーンを指定した場合**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul') AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul'))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3, 'Asia/Istanbul') │
└─────────────────────────┴─────────────────────────────────────────────────────────────────────┘
```
## toDateTime64
導入バージョン: v20.1.0
入力値を [`DateTime64`](/ja/reference/data-types/datetime64) 型の値に変換します。
**構文**
```sql theme={null}
toDateTime64(expr, scale[, timezone])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
* `scale` — ティックサイズ (精度) : 10^(-scale) Seconds。[`UInt8`](/ja/reference/data-types/int-uint)
* `timezone` — 任意。指定した `DateTime64` オブジェクトのタイムゾーン。[`String`](/ja/reference/data-types/string)
**戻り値**
秒未満の精度を持つ日付と時刻を返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**値が範囲内にある**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00.000', 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('2025-01-01 00:00:00.000', 3))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────────────────┘
```
**精度を指定した Decimal として**
```sql title=Query theme={null}
SELECT toDateTime64(1546300800.000, 3) AS value, toTypeName(value);
-- 小数点がなくても、この値は引き続き秒単位の Unix timestamp として扱われます
SELECT toDateTime64(1546300800000, 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64(1546300800000, 3))─┐
│ 2282-12-31 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────┘
```
**タイムゾーンあり**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul') AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul'))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3, 'Asia/Istanbul') │
└─────────────────────────┴─────────────────────────────────────────────────────────────────────┘
```
## toDateTime64OrDefault
導入バージョン: v21.11.0
[toDateTime64](#toDateTime64) と同様に、この関数は入力値を [DateTime64](/ja/reference/data-types/datetime64) 型の値に変換しますが、
無効な引数を受け取った場合は、[DateTime64](/ja/reference/data-types/datetime64) のデフォルト値
または指定されたデフォルト値を返します。
**構文**
```sql theme={null}
toDateTime64OrDefault(expr, scale[, timezone, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `scale` — ティックサイズ (精度) : 10^-precision Seconds。[`UInt8`](/ja/reference/data-types/int-uint)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
* `default` — 任意。パースに失敗した場合に返すデフォルト値。[`DateTime64`](/ja/reference/data-types/datetime64)
**戻り値**
成功した場合は DateTime64 型の値を返し、失敗した場合は、指定されていればデフォルト値を、指定されていなければ 1970-01-01 00:00:00.000 を返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toDateTime64OrDefault('1976-10-18 00:00:00.30', 3)
```
```response title=Response theme={null}
1976-10-18 00:00:00.300
```
**変換失敗**
```sql title=Query theme={null}
SELECT toDateTime64OrDefault('1976-10-18 00:00:00 30', 3, 'UTC', toDateTime64('2001-01-01 00:00:00.00',3))
```
```response title=Response theme={null}
2000-12-31 23:00:00.000
```
## toDateTime64OrNull
導入バージョン: v20.1.0
入力値を `DateTime64` 型の値に変換します。無効な引数を受け取った場合は `NULL` を返します。
`toDateTime64` と同様ですが、無効な引数を受け取った場合は `NULL` を返します。
**構文**
```sql theme={null}
toDateTime64OrNull(x)
```
**引数**
* `x` — 日時 (秒未満の精度を含む) の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は `DateTime64` 値を返し、失敗した場合は `NULL` を返します。[`DateTime64`](/ja/reference/data-types/datetime64) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDateTime64OrNull('2025-12-30 13:44:17.123'), toDateTime64OrNull('invalid')
```
```response title=Response theme={null}
┌─toDateTime64OrNull('2025-12-30 13:44:17.123')─┬─toDateTime64OrNull('invalid')─┐
│ 2025-12-30 13:44:17.123 │ ᴺᵁᴸᴸ │
└─────────────────────────────────────────────────┴───────────────────────────────┘
```
## toDateTime64OrZero
導入バージョン: v20.1.0
入力値を [DateTime64](/ja/reference/data-types/datetime64) 型の値に変換します。ただし、無効な引数を受け取った場合は [DateTime64](/ja/reference/data-types/datetime64) の下限値を返します。
[toDateTime64](#toDateTime64) と同様ですが、無効な引数を受け取った場合は [DateTime64](/ja/reference/data-types/datetime64) の下限値を返します。
関連項目:
* [toDateTime64](#toDateTime64).
* [toDateTime64OrNull](#toDateTime64OrNull).
* [toDateTime64OrDefault](#toDateTime64OrDefault).
**構文**
```sql theme={null}
toDateTime64OrZero(x)
```
**引数**
* `x` — 日時を秒未満の精度まで含む文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は DateTime64 値を返し、失敗した場合は DateTime64 の下限値 (`1970-01-01 00:00:00.000`) を返します。[`DateTime64`](/ja/reference/data-types/datetime64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDateTime64OrZero('2025-12-30 13:44:17.123'), toDateTime64OrZero('invalid')
```
```response title=Response theme={null}
┌─toDateTime64OrZero('2025-12-30 13:44:17.123')─┬─toDateTime64OrZero('invalid')─┐
│ 2025-12-30 13:44:17.123 │ 1970-01-01 00:00:00.000 │
└─────────────────────────────────────────────────┴─────────────────────────────────────┘
```
## toDateTimeOrDefault
導入バージョン: v21.11.0
[toDateTime](#toDateTime) と同様ですが、変換に失敗した場合はデフォルト値を返します。デフォルト値は、第3引数が指定されている場合はその値、指定されていない場合は [DateTime](/ja/reference/data-types/datetime) の下限値です。
**構文**
```sql theme={null}
toDateTimeOrDefault(expr[, timezone, default])
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `timezone` — 任意。タイムゾーン。[`String`](/ja/reference/data-types/string)
* `default` — 任意。パースに失敗した場合に返すデフォルト値。[`DateTime`](/ja/reference/data-types/datetime)
**戻り値**
成功した場合は DateTime 型の値を返します。失敗した場合は、`default` が渡されていればその値を返し、渡されていなければ 1970-01-01 00:00:00 を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toDateTimeOrDefault('2022-12-30 13:44:17')
```
```response title=Response theme={null}
2022-12-30 13:44:17
```
**変換失敗**
```sql title=Query theme={null}
SELECT toDateTimeOrDefault('', 'UTC', CAST('2023-01-01', 'DateTime(\'UTC\')'))
```
```response title=Response theme={null}
2023-01-01 00:00:00
```
## toDateTimeOrNull
導入バージョン: v1.1.0
入力値を `DateTime` 型の値に変換しますが、無効な引数が渡された場合は `NULL` を返します。
[`toDateTime`](#toDateTime) と同様ですが、無効な引数が渡された場合は `NULL` を返します。
**構文**
```sql theme={null}
toDateTimeOrNull(x)
```
**引数**
* `x` — 日時の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は `DateTime` 型の値を返し、それ以外の場合は `NULL` を返します。[`DateTime`](/ja/reference/data-types/datetime) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDateTimeOrNull('2025-12-30 13:44:17'), toDateTimeOrNull('invalid')
```
```response title=Response theme={null}
┌─toDateTimeOrNull('2025-12-30 13:44:17')─┬─toDateTimeOrNull('invalid')─┐
│ 2025-12-30 13:44:17 │ ᴺᵁᴸᴸ │
└─────────────────────────────────────────┴─────────────────────────────┘
```
## toDateTimeOrZero
導入バージョン: v1.1.0
入力値を [DateTime](/ja/reference/data-types/datetime) 型の値に変換します。無効な引数を受け取った場合は、[DateTime](/ja/reference/data-types/datetime) の下限値を返します。
[toDateTime](#toDateTime) と同じですが、無効な引数を受け取った場合は [DateTime](/ja/reference/data-types/datetime) の下限値を返します。
**構文**
```sql theme={null}
toDateTimeOrZero(x)
```
**引数**
* `x` — 日時の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は DateTime 型の値を返し、失敗した場合は DateTime の下限値 (`1970-01-01 00:00:00`) を返します。[`DateTime`](/ja/reference/data-types/datetime)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDateTimeOrZero('2025-12-30 13:44:17'), toDateTimeOrZero('invalid')
```
```response title=Response theme={null}
┌─toDateTimeOrZero('2025-12-30 13:44:17')─┬─toDateTimeOrZero('invalid')─┐
│ 2025-12-30 13:44:17 │ 1970-01-01 00:00:00 │
└─────────────────────────────────────────┴─────────────────────────────┘
```
## toDecimal128
導入バージョン: v18.12.0
入力値を、スケール `S` の [`Decimal(38, S)`](/ja/reference/data-types/decimal) 型の値に変換します。
エラー時には例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数:
* Float\* 型の値 `NaN` および `Inf` の文字列表現 (大文字と小文字を区別しません) 。
* 二進数値および16進数値の文字列表現。例: `SELECT toDecimal128('0xc0fe', 1);`。
`expr` の値が `Decimal128` の範囲 `(-1*10^(38 - S), 1*10^(38 - S))` を超えると、オーバーフローが発生する可能性があります。
小数部の桁数が多すぎる場合は切り捨てられます (丸めは行われません) 。
整数部の桁数が多すぎる場合は例外が発生します。
変換時には余分な桁が切り捨てられ、演算は浮動小数点命令を使って実行されるため、Float32/Float64 入力では予期しない動作になる可能性があります。
たとえば、`toDecimal128(1.15, 2)` は `1.14` になります。これは、浮動小数点では 1.15 \* 100 が 114.99 になるためです。
文字列入力を使うと、演算には基になる整数型が使用されます: `toDecimal128('1.15', 2) = 1.15`
**構文**
```sql theme={null}
toDecimal128(expr, S)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0 から 38 までのスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
型 `Decimal(38, S)` の値を返します。[`Decimal128(S)`](/ja/reference/data-types/decimal)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toDecimal128(99, 1) AS a, toTypeName(a) AS type_a,
toDecimal128(99.67, 2) AS b, toTypeName(b) AS type_b,
toDecimal128('99.67', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
行 1:
──────
a: 99
type_a: Decimal(38, 1)
b: 99.67
type_b: Decimal(38, 2)
c: 99.67
type_c: Decimal(38, 3)
```
## toDecimal128OrDefault
導入バージョン: v21.11.0
[`toDecimal128`](#toDecimal128) と同様に、この関数は入力値を [Decimal(38, S)](/ja/reference/data-types/decimal) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
**構文**
```sql theme={null}
toDecimal128OrDefault(expr, S[, default])
```
**引数**
* `expr` — 数値の文字列表現です。[`String`](/ja/reference/data-types/string)
* `S` — 0 から 38 までのスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
* `default` — 任意。Decimal128(S) 型へのパースに失敗した場合に返されるデフォルト値です。[`Decimal128(S)`](/ja/reference/data-types/decimal)
**戻り値**
成功した場合は Decimal(38, S) 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Decimal128(S)`](/ja/reference/data-types/decimal)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toDecimal128OrDefault(toString(1/42), 18)
```
```response title=Response theme={null}
0.023809523809523808
```
**変換失敗**
```sql title=Query theme={null}
SELECT toDecimal128OrDefault('Inf', 0, CAST('-1', 'Decimal128(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal128OrNull
導入バージョン: v20.1.0
入力値を [`Decimal(38, S)`](/ja/reference/data-types/decimal) 型の値に変換します。エラーが発生した場合は `NULL` を返します。
[`toDecimal128`](#toDecimal128) と同様ですが、変換エラー時に例外をスローする代わりに `NULL` を返します。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数 (`NULL` を返します) :
* Float\* 型の値 `NaN` および `Inf`、またはその文字列表現 (大文字と小文字を区別しません) 。
* バイナリ値および16進数値の文字列表現。
* `Decimal128` の範囲 `(-1*10^(38 - S), 1*10^(38 - S))` を超える値。
関連項目:
* [`toDecimal128`](#toDecimal128)。
* [`toDecimal128OrZero`](#toDecimal128OrZero)。
* [`toDecimal128OrDefault`](#toDecimal128OrDefault)。
**構文**
```sql theme={null}
toDecimal128OrNull(expr, S)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0～38 のスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Decimal(38, S) 型の値を返し、そうでない場合は `NULL` を返します。[`Decimal128(S)`](/ja/reference/data-types/decimal) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDecimal128OrNull('42.7', 2), toDecimal128OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal128OrNull('42.7', 2)─┬─toDecimal128OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal128OrZero
導入バージョン: v20.1.0
入力値を [Decimal(38, S)](/ja/reference/data-types/decimal) 型の値に変換します。エラーが発生した場合は `0` を返します。
[`toDecimal128`](#toDecimal128) と同様ですが、変換エラー時には例外をスローせず、`0` を返します。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数 (`0` を返します):
* Float\* 型の値 `NaN` および `Inf`、またはその文字列表現 (大文字と小文字を区別しません) 。
* 2 進数および 16 進数の文字列表現。
入力値が `Decimal128` の範囲 `(-1*10^(38 - S), 1*10^(38 - S))` を超える場合、この関数は `0` を返します。
**構文**
```sql theme={null}
toDecimal128OrZero(expr, S)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0 から 38 までのスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Decimal(38, S) の値を返し、失敗した場合は `0` を返します。[`Decimal128(S)`](/ja/reference/data-types/decimal)
**例**
**基本的な使い方**
```sql title=Query theme={null}
SELECT toDecimal128OrZero('42.7', 2), toDecimal128OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal128OrZero('42.7', 2)─┬─toDecimal128OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal256
導入バージョン: v20.8.0
入力値を、スケール `S` を持つ [`Decimal(76, S)`](/ja/reference/data-types/decimal) 型の値に変換します。エラーが発生した場合は例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数:
* Float\* 値 `NaN` および `Inf` の値、またはその文字列表現 (大文字と小文字を区別しません) 。
* バイナリ値および16進数値の文字列表現。例: `SELECT toDecimal256('0xc0fe', 1);`。
`expr` の値が `Decimal256` の範囲 `(-1*10^(76 - S), 1*10^(76 - S))` を超えると、オーバーフローが発生する可能性があります。
小数部の桁数が多すぎる場合は切り捨てられます (丸めは行われません) 。
整数部の桁数が多すぎる場合は例外が発生します。
変換時には余分な桁が切り捨てられ、演算は浮動小数点命令を使って実行されるため、Float32/Float64 入力では予期しない動作になることがあります。
例: `toDecimal256(1.15, 2)` は `1.14` になります。これは、浮動小数点演算では 1.15 \* 100 が 114.99 になるためです。
文字列入力を使用すると、演算には基になる整数型が使われます: `toDecimal256('1.15', 2) = 1.15`
**構文**
```sql theme={null}
toDecimal256(expr, S)
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0 から 76 までのスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
`Decimal(76, S)` 型の値を返します。[`Decimal256(S)`](/ja/reference/data-types/decimal)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toDecimal256(99, 1) AS a, toTypeName(a) AS type_a,
toDecimal256(99.67, 2) AS b, toTypeName(b) AS type_b,
toDecimal256('99.67', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
行 1:
──────
a: 99
type_a: Decimal(76, 1)
b: 99.67
type_b: Decimal(76, 2)
c: 99.67
type_c: Decimal(76, 3)
```
## toDecimal256OrDefault
導入バージョン: v21.11.0
[`toDecimal256`](#toDecimal256) と同様に、この関数は入力値を [Decimal(76, S)](/ja/reference/data-types/decimal) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
**構文**
```sql theme={null}
toDecimal256OrDefault(expr, S[, default])
```
**引数**
* `expr` — 数値の文字列表現です。[`String`](/ja/reference/data-types/string)
* `S` — 0〜76 のスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
* `default` — 任意。Decimal256(S) 型へのパースに失敗した場合に返すデフォルト値です。[`Decimal256(S)`](/ja/reference/data-types/decimal)
**戻り値**
成功した場合は Decimal(76, S) 型の値を返し、それ以外の場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Decimal256(S)`](/ja/reference/data-types/decimal)
**例**
**変換成功**
```sql title=Query theme={null}
SELECT toDecimal256OrDefault(toString(1/42), 76)
```
```response title=Response theme={null}
0.023809523809523808
```
**変換に失敗**
```sql title=Query theme={null}
SELECT toDecimal256OrDefault('Inf', 0, CAST('-1', 'Decimal256(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal256OrNull
導入バージョン: v20.8.0
入力値を [`Decimal(76, S)`](/ja/reference/data-types/decimal) 型の値に変換します。エラーが発生した場合は `NULL` を返します。
[`toDecimal256`](#toDecimal256) と同様ですが、変換エラー時に例外をスローする代わりに `NULL` を返します。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数 (`NULL` を返します) :
* Float\* 型の値 `NaN` および `Inf`、またはその文字列表現 (大文字と小文字を区別しません) 。
* バイナリ値および16進値の文字列表現。
* `Decimal256` の範囲を超える値: `(-1 * 10^(76 - S), 1 * 10^(76 - S))`。
関連項目:
* [`toDecimal256`](#toDecimal256)。
* [`toDecimal256OrZero`](#toDecimal256OrZero)。
* [`toDecimal256OrDefault`](#toDecimal256OrDefault)。
**構文**
```sql theme={null}
toDecimal256OrNull(expr, S)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0 から 76 までのスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Decimal(76, S) の値を返し、それ以外の場合は `NULL` を返します。[`Decimal256(S)`](/ja/reference/data-types/decimal) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDecimal256OrNull('42.7', 2), toDecimal256OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal256OrNull('42.7', 2)─┬─toDecimal256OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal256OrZero
導入バージョン: v20.8.0
入力値を [Decimal(76, S)](/ja/reference/data-types/decimal) 型の値に変換します。エラーが発生した場合は `0` を返します。
[`toDecimal256`](#toDecimal256) と同様ですが、変換エラー時に例外をスローする代わりに `0` を返します。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数 (`0` を返します):
* Float\* 型の値 `NaN` および `Inf` の値、またはその文字列表現 (大文字と小文字を区別しません) 。
* バイナリ値および16進数値の文字列表現。
入力値が `Decimal256` の範囲 `(-1*10^(76 - S), 1*10^(76 - S))` を超える場合、関数は `0` を返します。
関連項目:
* [`toDecimal256`](#toDecimal256).
* [`toDecimal256OrNull`](#toDecimal256OrNull).
* [`toDecimal256OrDefault`](#toDecimal256OrDefault).
**構文**
```sql theme={null}
toDecimal256OrZero(expr, S)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0 から 76 までのスケールパラメータで、数値の小数部に含められる桁数を指定します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は `Decimal(76, S)` の値を返し、失敗した場合は `0` を返します。[`Decimal256(S)`](/ja/reference/data-types/decimal)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDecimal256OrZero('42.7', 2), toDecimal256OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal256OrZero('42.7', 2)─┬─toDecimal256OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal32
導入バージョン: v18.12.0
入力値を、スケール `S` の [`Decimal(9, S)`](/ja/reference/data-types/decimal) 型の値に変換します。エラーが発生した場合は例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数:
* Float\* 型の値 `NaN` および `Inf`、またはそれらの文字列表現 (大文字と小文字を区別しません) 。
* バイナリ値および16進数値の文字列表現。例: `SELECT toDecimal32('0xc0fe', 1);`。
`expr` の値が `Decimal32` の範囲 `(-1*10^(9 - S), 1*10^(9 - S))` を超えると、オーバーフローが発生する可能性があります。
小数部の桁数が多すぎる場合は切り捨てられます (丸めは行われません) 。
整数部の桁数が多すぎる場合は例外になります。
変換時には余分な桁が切り捨てられ、演算は浮動小数点命令を使って実行されるため、Float32/Float64 入力を扱う場合は予期しない結果になることがあります。
例: `toDecimal32(1.15, 2)` は `1.14` になります。これは、浮動小数点では 1.15 \* 100 が 114.99 になるためです。
代わりに String 入力を使うと、演算に基になる整数型が使用されます: `toDecimal32('1.15', 2) = 1.15`
**構文**
```sql theme={null}
toDecimal32(expr, S)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0〜9 のスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
`Decimal(9, S)` 型の値を返します。[`Decimal32(S)`](/ja/reference/data-types/decimal)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toDecimal32(2, 1) AS a, toTypeName(a) AS type_a,
toDecimal32(4.2, 2) AS b, toTypeName(b) AS type_b,
toDecimal32('4.2', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
行 1:
──────
a: 2
type_a: Decimal(9, 1)
b: 4.2
type_b: Decimal(9, 2)
c: 4.2
type_c: Decimal(9, 3)
```
## toDecimal32OrDefault
導入バージョン: v21.11.0
[`toDecimal32`](#toDecimal32) と同様に、この関数は入力値を [Decimal(9, S)](/ja/reference/data-types/decimal) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
**構文**
```sql theme={null}
toDecimal32OrDefault(expr, S[, default])
```
**引数**
* `expr` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
* `S` — 0 から 9 までのスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
* `default` — 任意。Decimal32(S) 型へのパースに失敗した場合に返されるデフォルト値。[`Decimal32(S)`](/ja/reference/data-types/decimal)
**戻り値**
成功した場合は Decimal(9, S) 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Decimal32(S)`](/ja/reference/data-types/decimal)
**例**
**変換成功**
```sql title=Query theme={null}
SELECT toDecimal32OrDefault(toString(0.0001), 5)
```
```response title=Response theme={null}
0.0001
```
**変換に失敗**
```sql title=Query theme={null}
SELECT toDecimal32OrDefault('Inf', 0, CAST('-1', 'Decimal32(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal32OrNull
導入バージョン: v20.1.0
入力値を [`Decimal(9, S)`](/ja/reference/data-types/decimal) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
[`toDecimal32`](#toDecimal32) と同様ですが、変換エラー時に例外をスローする代わりに `NULL` を返します。
サポートされる引数:
* 型 (U)Int\* の値、またはその文字列表現。
* 型 Float\* の値、またはその文字列表現。
サポートされない引数 (`NULL` を返します):
* Float\* 型の値 `NaN` および `Inf`、またはそれらの文字列表現 (大文字と小文字を区別しません) 。
* 2進数および16進数の文字列表現。
* `Decimal32` の範囲 `(-1*10^(9 - S), 1*10^(9 - S))` を超える値。
関連項目:
* [`toDecimal32`](#toDecimal32)。
* [`toDecimal32OrZero`](#toDecimal32OrZero)。
* [`toDecimal32OrDefault`](#toDecimal32OrDefault)。
**構文**
```sql theme={null}
toDecimal32OrNull(expr, S)
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。 [`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0 から 9 までのスケールパラメータで、数値の小数部の桁数を指定します。 [`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は `Decimal(9, S)` の値を返し、それ以外の場合は `NULL` を返します。 [`Decimal32(S)`](/ja/reference/data-types/decimal) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDecimal32OrNull('42.7', 2), toDecimal32OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal32OrNull('42.7', 2)─┬─toDecimal32OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimal32OrZero
導入バージョン: v20.1.0
入力値を [Decimal(9, S)](/ja/reference/data-types/decimal) 型の値に変換します。エラーが発生した場合は `0` を返します。
[`toDecimal32`](#toDecimal32) と同様ですが、変換エラー時に例外を送出する代わりに `0` を返します。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数 (`0` を返します) :
* Float\* 型の値 `NaN` および `Inf`、またはそれらの文字列表現 (大文字と小文字を区別しません) 。
* 2進数および16進数の文字列表現。
入力値が `Decimal32` の範囲 `(-1*10^(9 - S), 1*10^(9 - S))` を超える場合、この関数は `0` を返します。
**構文**
```sql theme={null}
toDecimal32OrZero(expr, S)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0 から 9 までのスケールパラメータで、数値の小数部の桁数を指定します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Decimal(9, S) 値を返し、失敗した場合は `0` を返します。[`Decimal32(S)`](/ja/reference/data-types/decimal)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDecimal32OrZero('42.7', 2), toDecimal32OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal32OrZero('42.7', 2)─┬─toDecimal32OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimal64
導入バージョン: v18.12.0
入力値を、スケール `S` を持つ [`Decimal(18, S)`](/ja/reference/data-types/decimal) 型の値に変換します。
エラーが発生した場合は例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数:
* Float\* 型の値 `NaN` および `Inf`、またはそれらの文字列表現 (大文字と小文字は区別されません) 。
* 2進数および16進数の値の文字列表現。例: `SELECT toDecimal64('0xc0fe', 1);`。
`expr` の値が `Decimal64` の範囲 `(-1*10^(18 - S), 1*10^(18 - S))` を超えると、オーバーフローが発生する可能性があります。
小数部の余分な桁は切り捨てられます (丸められません) 。
整数部の桁数が多すぎる場合は例外が発生します。
変換では余分な桁が切り捨てられ、演算は浮動小数点命令を使用して実行されるため、Float32/Float64 入力を扱う場合は予期しない動作になる可能性があります。
たとえば、`toDecimal64(1.15, 2)` は `1.14` になります。これは、浮動小数点では 1.15 \* 100 が 114.99 になるためです。
文字列入力を使用すると、演算には内部の整数型が使われます: `toDecimal64('1.15', 2) = 1.15`
**構文**
```sql theme={null}
toDecimal64(expr, S)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0〜18 のスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
Decimal 値を返します。[`Decimal(18, S)`](/ja/reference/data-types/decimal)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toDecimal64(2, 1) AS a, toTypeName(a) AS type_a,
toDecimal64(4.2, 2) AS b, toTypeName(b) AS type_b,
toDecimal64('4.2', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
行 1:
──────
a: 2.0
type_a: Decimal(18, 1)
b: 4.20
type_b: Decimal(18, 2)
c: 4.200
type_c: Decimal(18, 3)
```
## toDecimal64OrDefault
導入バージョン: v21.11.0
この関数は [`toDecimal64`](#toDecimal64) と同様に、入力値を [Decimal(18, S)](/ja/reference/data-types/decimal) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
**構文**
```sql theme={null}
toDecimal64OrDefault(expr, S[, default])
```
**引数**
* `expr` — 数値の文字列表現です。[`String`](/ja/reference/data-types/string)
* `S` — 0 から 18 までのスケールパラメータで、数値の小数部に指定できる桁数を表します。[`UInt8`](/ja/reference/data-types/int-uint)
* `default` — 任意。Decimal64(S) 型へのパースに失敗した場合に返すデフォルト値です。[`Decimal64(S)`](/ja/reference/data-types/decimal)
**戻り値**
成功した場合は Decimal(18, S) 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Decimal64(S)`](/ja/reference/data-types/decimal)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toDecimal64OrDefault(toString(0.0001), 18)
```
```response title=Response theme={null}
0.0001
```
**変換の失敗**
```sql title=Query theme={null}
SELECT toDecimal64OrDefault('Inf', 0, CAST('-1', 'Decimal64(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal64OrNull
導入バージョン: v20.1.0
入力値を [Decimal(18, S)](/ja/reference/data-types/decimal) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
[`toDecimal64`](#toDecimal64) と同様ですが、変換エラー時に例外をスローする代わりに `NULL` を返します。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数 (`NULL` を返します) :
* Float\* 型の値 `NaN` および `Inf`、またはそれらの文字列表現 (大文字と小文字を区別しません) 。
* 2進数および16進数の値の文字列表現。
* `Decimal64` の範囲 `(-1*10^(18 - S), 1*10^(18 - S))` を超える値。
関連項目:
* [`toDecimal64`](#toDecimal64).
* [`toDecimal64OrZero`](#toDecimal64OrZero).
* [`toDecimal64OrDefault`](#toDecimal64OrDefault).
**構文**
```sql theme={null}
toDecimal64OrNull(expr, S)
```
**引数**
* `expr` — 数値、または数値を文字列で表したものを返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0 から 18 までのスケールパラメータで、数値の小数部の桁数を指定します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Decimal(18, S) の値を返し、失敗した場合は `NULL` を返します。[`Decimal64(S)`](/ja/reference/data-types/decimal) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDecimal64OrNull('42.7', 2), toDecimal64OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal64OrNull('42.7', 2)─┬─toDecimal64OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimal64OrZero
導入バージョン: v20.1.0
入力値を [Decimal(18, S)](/ja/reference/data-types/decimal) 型の値に変換します。エラーが発生した場合は `0` を返します。
[`toDecimal64`](#toDecimal64) と同様ですが、変換エラー時に例外をスローする代わりに `0` を返します。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値、またはその文字列表現。
サポートされない引数 (`0` を返します) :
* Float\* 型の値 `NaN` および `Inf`、またはそれらの文字列表現 (大文字と小文字は区別されません) 。
* 2進数および16進数の文字列表現。
入力値が `Decimal64` の範囲 `(-1*10^(18 - S), 1*10^(18 - S))` を超える場合、この関数は `0` を返します。
関連項目:
* [`toDecimal64`](#toDecimal64)。
* [`toDecimal64OrNull`](#toDecimal64OrNull)。
* [`toDecimal64OrDefault`](#toDecimal64OrDefault)。
**構文**
```sql theme={null}
toDecimal64OrZero(expr, S)
```
**引数**
* `expr` — 数値、または数値を文字列で表したものを返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
* `S` — 0 から 18 までのスケールパラメータで、数値の小数部の桁数を指定します。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Decimal(18, S) の値を返し、それ以外の場合は `0` を返します。[`Decimal64(S)`](/ja/reference/data-types/decimal)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toDecimal64OrZero('42.7', 2), toDecimal64OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal64OrZero('42.7', 2)─┬─toDecimal64OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimalString
導入バージョン: v23.3.0
数値を、指定した小数点以下の桁数を持つ String に変換します。
この関数は、入力値を指定した小数点以下の桁数に丸めます。入力値の小数点以下の桁数が指定された桁数より少ない
場合は、指定どおりの小数点以下の桁数になるよう、結果の末尾が 0 で埋められます。
**構文**
```sql theme={null}
toDecimalString(number, scale)
```
**引数**
* `number` — 文字列に変換する数値です。任意の数値型 (Int、UInt、Float、Decimal) を指定できます。[`Int8`](/ja/reference/data-types/int-uint) または [`Int16`](/ja/reference/data-types/int-uint) または [`Int32`](/ja/reference/data-types/int-uint) または [`Int64`](/ja/reference/data-types/int-uint) または [`UInt8`](/ja/reference/data-types/int-uint) または [`UInt16`](/ja/reference/data-types/int-uint) または [`UInt32`](/ja/reference/data-types/int-uint) または [`UInt64`](/ja/reference/data-types/int-uint) または [`Float32`](/ja/reference/data-types/float) または [`Float64`](/ja/reference/data-types/float) または [`Decimal`](/ja/reference/data-types/decimal)
* `scale` — 小数部に表示する桁数です。必要に応じて結果は丸められます。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
指定した小数点以下の桁数で、数値を文字列として返します。[`String`](/ja/reference/data-types/string)
**例**
**数値を丸めてフォーマットする**
```sql title=Query theme={null}
SELECT toDecimalString(2.1456, 2)
```
```response title=Response theme={null}
┌─toDecimalString(2.1456, 2)─┐
│ 2.15 │
└────────────────────────────┘
```
**0で埋める**
```sql title=Query theme={null}
SELECT toDecimalString(5, 3)
```
```response title=Response theme={null}
┌─toDecimalString(5, 3)─┐
│ 5.000 │
└───────────────────────┘
```
**さまざまな数値型**
```sql title=Query theme={null}
SELECT toDecimalString(CAST(123.456 AS Decimal(10,3)), 2) AS decimal_val,
toDecimalString(CAST(42.7 AS Float32), 4) AS float_val
```
```response title=Response theme={null}
┌─decimal_val─┬─float_val─┐
│ 123.46 │ 42.7000 │
└─────────────┴───────────┘
```
## toFixedString
導入バージョン: v1.1.0
[`String`](/ja/reference/data-types/string) 型の引数を [`FixedString(N)`](/ja/reference/data-types/fixedstring) 型 (長さ N の固定長文字列) に変換します。
文字列のバイト数が N 未満の場合は、右側が null バイトで埋められます。
文字列のバイト数が N を超える場合は、例外が発生します。
**構文**
```sql theme={null}
toFixedString(s, N)
```
**引数**
* `s` — 変換する文字列。[`String`](/ja/reference/data-types/string)
* `N` — 生成される FixedString の長さ。[`const UInt*`](/ja/reference/data-types/int-uint)
**戻り値**
長さ N の FixedString を返します。[`FixedString(N)`](/ja/reference/data-types/fixedstring)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toFixedString('foo', 8) AS s;
```
```response title=Response theme={null}
┌─s─────────────┐
│ foo\0\0\0\0\0 │
└───────────────┘
```
## toFloat32
導入バージョン: v1.1.0
入力値を [Float32](/ja/reference/data-types/float) 型の値に変換します。
エラーが発生した場合は例外を送出します。
サポートされる引数:
* (U)Int\* 型の値。
* (U)Int8/16/32/128/256 の文字列表現。
* `NaN` および `Inf` を含む Float\* 型の値。
* `NaN` および `Inf` を含む Float\* の文字列表現 (大文字と小文字を区別しません) 。
サポートされない引数:
* 2進数および16進数の文字列表現。たとえば `SELECT toFloat32('0xc0fe');`。
関連項目:
* [`toFloat32OrZero`](#toFloat32OrZero)。
* [`toFloat32OrNull`](#toFloat32OrNull)。
* [`toFloat32OrDefault`](#toFloat32OrDefault)。
**構文**
```sql theme={null}
toFloat32(expr)
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
32 ビット浮動小数点数の値を返します。[`Float32`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toFloat32(42.7),
toFloat32('42.7'),
toFloat32('NaN')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat32(42.7): 42.7
toFloat32('42.7'): 42.7
toFloat32('NaN'): nan
```
## toFloat32OrDefault
導入バージョン: v21.11.0
[`toFloat32`](#toFloat32) と同様に、この関数は入力値を [Float32](/ja/reference/data-types/float) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が渡されていない場合、エラー時には `0` が返されます。
**構文**
```sql theme={null}
toFloat32OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 省略可能。パースに失敗した場合に返されるデフォルト値。[`Float32`](/ja/reference/data-types/float)
**戻り値**
成功した場合は Float32 型の値を返し、失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Float32`](/ja/reference/data-types/float)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toFloat32OrDefault('8', CAST('0', 'Float32'))
```
```response title=Response theme={null}
8
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toFloat32OrDefault('abc', CAST('0', 'Float32'))
```
```response title=Response theme={null}
0
```
## toFloat32OrNull
導入バージョン: v1.1.0
入力値を [Float32](/ja/reference/data-types/float) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
[`toFloat32`](#toFloat32) と同様ですが、変換エラー時に例外をスローする代わりに `NULL` を返します。
サポートされる引数:
* 型 (U)Int\* の値。
* (U)Int8/16/32/128/256 の文字列表現。
* `NaN` および `Inf` を含む、型 Float\* の値。
* `NaN` および `Inf` を含む、Float\* の文字列表現 (大文字と小文字を区別しません) 。
サポートされない引数 (`NULL` を返します):
* 2進数および16進数の文字列表現。例: `SELECT toFloat32OrNull('0xc0fe');`。
* 無効な文字列フォーマット。
関連項目:
* [`toFloat32`](#toFloat32)。
* [`toFloat32OrZero`](#toFloat32OrZero)。
* [`toFloat32OrDefault`](#toFloat32OrDefault)。
**構文**
```sql theme={null}
toFloat32OrNull(x)
```
**引数**
* `x` — 数値を表す文字列。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は 32 ビットの Float 値を返し、失敗した場合は `NULL` を返します。[`Float32`](/ja/reference/data-types/float) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toFloat32OrNull('42.7'),
toFloat32OrNull('NaN'),
toFloat32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat32OrNull('42.7'): 42.7
toFloat32OrNull('NaN'): nan
toFloat32OrNull('abc'): \N
```
## toFloat32OrZero
導入バージョン: v1.1.0
入力値を [Float32](/ja/reference/data-types/float) 型の値に変換します。エラーが発生した場合は `0` を返します。
[`toFloat32`](#toFloat32) と似ていますが、変換エラー時に例外をスローする代わりに `0` を返します。
関連項目:
* [`toFloat32`](#toFloat32)。
* [`toFloat32OrNull`](#toFloat32OrNull)。
* [`toFloat32OrDefault`](#toFloat32OrDefault)。
**構文**
```sql theme={null}
toFloat32OrZero(x)
```
**引数**
* `x` — 数値の文字列表現。 [`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は 32 ビットの浮動小数点値を返し、それ以外の場合は `0` を返します。 [`Float32`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toFloat32OrZero('42.7'),
toFloat32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat32OrZero('42.7'): 42.7
toFloat32OrZero('abc'): 0
```
## toFloat64
導入バージョン: v1.1.0
入力値を [`Float64`](/ja/reference/data-types/float) 型の値に変換します。
エラーが発生した場合は例外をスローします。
サポートされる引数:
* (U)Int\* 型の値。
* (U)Int8/16/32/128/256 の文字列表現。
* `NaN` と `Inf` を含む Float\* 型の値。
* `NaN` と `Inf` を含む Float\* 型の文字列表現 (大文字と小文字は区別されません) 。
サポートされない引数:
* 2 進数および 16 進数の値の文字列表現。例: `SELECT toFloat64('0xc0fe');`。
関連項目:
* [`toFloat64OrZero`](#toFloat64OrZero)。
* [`toFloat64OrNull`](#toFloat64OrNull)。
* [`toFloat64OrDefault`](#toFloat64OrDefault)。
**構文**
```sql theme={null}
toFloat64(expr)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
64ビット浮動小数点値を返します。[`Float64`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toFloat64(42.7),
toFloat64('42.7'),
toFloat64('NaN')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat64(42.7): 42.7
toFloat64('42.7'): 42.7
toFloat64('NaN'): nan
```
## toFloat64OrDefault
導入バージョン: v21.11.0
[`toFloat64`](#toFloat64) と同様に、この関数は入力値を [Float64](/ja/reference/data-types/float) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が渡されない場合、エラー時には `0` が返されます。
**構文**
```sql theme={null}
toFloat64OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返すデフォルト値。[`Float64`](/ja/reference/data-types/float)
**戻り値**
成功した場合は Float64 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Float64`](/ja/reference/data-types/float)
**例**
**変換に成功した例**
```sql title=Query theme={null}
SELECT toFloat64OrDefault('8', CAST('0', 'Float64'))
```
```response title=Response theme={null}
8
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toFloat64OrDefault('abc', CAST('0', 'Float64'))
```
```response title=Response theme={null}
0
```
## toFloat64OrNull
導入バージョン: v1.1.0
入力値を [Float64](/ja/reference/data-types/float) 型の値に変換します。エラーが発生した場合は `NULL` を返します。
[`toFloat64`](#toFloat64) と同様ですが、変換エラー時に例外を送出する代わりに `NULL` を返します。
サポートされる引数:
* (U)Int\* 型の値。
* (U)Int8/16/32/128/256 の文字列表現。
* `NaN` および `Inf` を含む Float\* 型の値。
* `NaN` および `Inf` を含む Float\* 型の文字列表現 (大文字と小文字を区別しません) 。
サポートされない引数 (`NULL` を返します) :
* 2進数値および16進数値の文字列表現。例: `SELECT toFloat64OrNull('0xc0fe');`。
* 無効な文字列形式。
関連項目:
* [`toFloat64`](#toFloat64)。
* [`toFloat64OrZero`](#toFloat64OrZero)。
* [`toFloat64OrDefault`](#toFloat64OrDefault)。
**構文**
```sql theme={null}
toFloat64OrNull(x)
```
**引数**
* `x` — 数値を表す文字列です。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は 64 ビットの浮動小数点値を返し、失敗した場合は `NULL` を返します。[`Float64`](/ja/reference/data-types/float) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toFloat64OrNull('42.7'),
toFloat64OrNull('NaN'),
toFloat64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat64OrNull('42.7'): 42.7
toFloat64OrNull('NaN'): nan
toFloat64OrNull('abc'): \N
```
## toFloat64OrZero
導入バージョン: v1.1.0
入力値を [Float64](/ja/reference/data-types/float) 型の値に変換します。エラーが発生した場合は `0` を返します。
[`toFloat64`](#toFloat64) と同様ですが、変換エラー時に例外をスローする代わりに `0` を返します。
関連項目:
* [`toFloat64`](#toFloat64)。
* [`toFloat64OrNull`](#toFloat64OrNull)。
* [`toFloat64OrDefault`](#toFloat64OrDefault)。
**構文**
```sql theme={null}
toFloat64OrZero(x)
```
**引数**
* `x` — 数値を表す文字列です。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は 64 ビットの浮動小数点値を返し、失敗した場合は `0` を返します。[`Float64`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toFloat64OrZero('42.7'),
toFloat64OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat64OrZero('42.7'): 42.7
toFloat64OrZero('abc'): 0
```
## toInt128
導入バージョン: v1.1.0
入力値を [Int128](/ja/reference/data-types/int-uint) 型の値に変換します。
エラーが発生した場合は例外をスローします。
この関数ではゼロ方向への丸めが使用されるため、数値の小数点以下の桁数は切り捨てられます。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` および `Inf` を含む、Float\* 型の値を表す文字列。
* 2 進数および 16 進数の値を表す文字列。例: `SELECT toInt128('0xc0fe');`。
入力値が Int128 の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toInt128OrZero`](#toInt128OrZero)。
* [`toInt128OrNull`](#toInt128OrNull)。
* [`toInt128OrDefault`](#toInt128OrDefault)。
**構文**
```sql theme={null}
toInt128(expr)
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
128 ビット整数値を返します。[`Int128`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt128(-128),
toInt128(-128.8),
toInt128('-128')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt128(-128): -128
toInt128(-128.8): -128
toInt128('-128'): -128
```
## toInt128OrDefault
導入バージョン: v21.11.0
[`toInt128`](#toInt128) と同様に、この関数は入力値を [Int128](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が渡されない場合は、エラー時に `0` が返されます。
**構文**
```sql theme={null}
toInt128OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返すデフォルト値。[`Int128`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Int128 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Int128`](/ja/reference/data-types/int-uint)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toInt128OrDefault('-128', CAST('-1', 'Int128'))
```
```response title=Response theme={null}
-128
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toInt128OrDefault('abc', CAST('-1', 'Int128'))
```
```response title=Response theme={null}
-1
```
## toInt128OrNull
導入バージョン: v20.8.0
[`toInt128`](#toInt128) と同様に、この関数は入力値を [Int128](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2 進数および 16 進数の文字列表現。例: `SELECT toInt128OrNull('0xc0fe');`。
入力値が [Int128](/ja/reference/data-types/int-uint) の範囲内に収まらない場合、結果でオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toInt128`](#toInt128).
* [`toInt128OrZero`](#toInt128OrZero).
* [`toInt128OrDefault`](#toInt128OrDefault).
**構文**
```sql theme={null}
toInt128OrNull(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
`Int128` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`Int128`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt128OrNull('-128'),
toInt128OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt128OrNull('-128'): -128
toInt128OrNull('abc'): \N
```
## toInt128OrZero
導入バージョン: v20.8.0
入力値を [Int128](/ja/reference/data-types/int-uint) 型に変換します。エラーが発生した場合は `0` を返します。
[`toInt128`](#toInt128) と同様ですが、例外をスローする代わりに `0` を返します。
関連項目:
* [`toInt128`](#toInt128).
* [`toInt128OrNull`](#toInt128OrNull).
* [`toInt128OrDefault`](#toInt128OrDefault).
**構文**
```sql theme={null}
toInt128OrZero(x)
```
**引数**
* `x` — 変換対象の入力値。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`Float*`](/ja/reference/data-types/float) または [`Decimal`](/ja/reference/data-types/decimal) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime)
**戻り値**
変換後の入力値を返します。変換に失敗した場合は `0` を返します。[`Int128`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toInt128OrZero('123')
```
```response title=Response theme={null}
123
```
**変換に失敗した場合は 0 を返します**
```sql title=Query theme={null}
SELECT toInt128OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt16
導入バージョン: v1.1.0
入力値を [`Int16`](/ja/reference/data-types/int-uint) 型の値に変換します。
エラーが発生した場合は例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` や `Inf` を含む、Float\* 型の値の文字列表現。
* 2進数および16進数の値の文字列表現。例: `SELECT toInt16('0xc0fe');`。
入力値が [Int16](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果でオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
例: `SELECT toInt16(32768) == -32768;`。
この関数は [ゼロ方向への丸め](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero) を使用します。つまり、数値の小数点以下の桁数を切り捨てます。
関連項目:
* [`toInt16OrZero`](#toInt16OrZero)。
* [`toInt16OrNull`](#toInt16OrNull)。
* [`toInt16OrDefault`](#toInt16OrDefault)。
**構文**
```sql theme={null}
toInt16(expr)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
16ビット整数の値を返します。[`Int16`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt16(-16),
toInt16(-16.16),
toInt16('-16')
FORMAT Vertical
```
```response title=Response theme={null}
行 1:
──────
toInt16(-16): -16
toInt16(-16.16): -16
toInt16('-16'): -16
```
## toInt16OrDefault
導入バージョン: v21.11.0
[`toInt16`](#toInt16) と同様に、この関数は入力値を [Int16](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が渡されていない場合、エラー時には `0` が返されます。
**構文**
```sql theme={null}
toInt16OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返されるデフォルト値。[`Int16`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Int16 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Int16`](/ja/reference/data-types/int-uint)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toInt16OrDefault('-16', CAST('-1', 'Int16'))
```
```response title=Response theme={null}
-16
```
**変換に失敗しました**
```sql title=Query theme={null}
SELECT toInt16OrDefault('abc', CAST('-1', 'Int16'))
```
```response title=Response theme={null}
-1
```
## toInt16OrNull
導入バージョン: v1.1.0
[`toInt16`](#toInt16) と同様に、この関数は入力値を [Int16](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2進数および16進数の値の文字列表現。例: `SELECT toInt16OrNull('0xc0fe');`。
入力値が [Int16](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果でオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toInt16`](#toInt16)。
* [`toInt16OrZero`](#toInt16OrZero)。
* [`toInt16OrDefault`](#toInt16OrDefault)。
**構文**
```sql theme={null}
toInt16OrNull(x)
```
**引数**
* `x` — 数値を表す文字列。 [`String`](/ja/reference/data-types/string)
**戻り値**
変換が成功した場合は `Int16` 型の値を返し、失敗した場合は `NULL` を返します。 [`Int16`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt16OrNull('-16'),
toInt16OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt16OrNull('-16'): -16
toInt16OrNull('abc'): \N
```
## toInt16OrZero
導入バージョン: v1.1.0
この関数は [`toInt16`](#toInt16) と同様に、入力値を [Int16](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `0` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`0` を返す) :
* `NaN` および `Inf` を含む Float\* 値の文字列表現。
* 2進数および16進数の値の文字列表現。例: `SELECT toInt16OrZero('0xc0fe');`。
入力値が [Int16](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果としてオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toInt16`](#toInt16)。
* [`toInt16OrNull`](#toInt16OrNull)。
* [`toInt16OrDefault`](#toInt16OrDefault)。
**構文**
```sql theme={null}
toInt16OrZero(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
`Int16` 型の値を返します。変換に失敗した場合は `0` を返します。[`Int16`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt16OrZero('16'),
toInt16OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt16OrZero('16'): 16
toInt16OrZero('abc'): 0
```
## toInt256
導入バージョン: v1.1.0
入力値を [Int256](/ja/reference/data-types/int-uint) 型の値に変換します。
エラーが発生した場合は例外をスローします。
この関数ではゼロ方向への丸めが使用されるため、数値の小数点以下の桁数は切り捨てられます。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` および `Inf` を含む、Float\* 型の値の文字列表現。
* 2進数および16進数の値の文字列表現。例: `SELECT toInt256('0xc0fe');`。
入力値が Int256 の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toInt256OrZero`](#toInt256OrZero)。
* [`toInt256OrNull`](#toInt256OrNull)。
* [`toInt256OrDefault`](#toInt256OrDefault)。
**構文**
```sql theme={null}
toInt256(expr)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
256 ビットの整数値を返します。[`Int256`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt256(-256),
toInt256(-256.256),
toInt256('-256')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt256(-256): -256
toInt256(-256.256): -256
toInt256('-256'): -256
```
## toInt256OrDefault
導入バージョン: v21.11.0
[`toInt256`](#toInt256) と同様に、この関数は入力値を [Int256](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が渡されない場合は、エラー時に `0` が返されます。
**構文**
```sql theme={null}
toInt256OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返すデフォルト値。[`Int256`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Int256 型の値を返します。失敗した場合は、指定されていればデフォルト値を返し、指定されていなければ 0 を返します。[`Int256`](/ja/reference/data-types/int-uint)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toInt256OrDefault('-256', CAST('-1', 'Int256'))
```
```response title=Response theme={null}
-256
```
**変換に失敗**
```sql title=Query theme={null}
SELECT toInt256OrDefault('abc', CAST('-1', 'Int256'))
```
```response title=Response theme={null}
-1
```
## toInt256OrNull
導入バージョン: v20.8.0
[`toInt256`](#toInt256) と同様に、この関数は入力値を [Int256](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む Float\* 値の文字列表現。
* 2進数および16進数の値の文字列表現。例: `SELECT toInt256OrNull('0xc0fe');`。
入力値が [Int256](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果でオーバーフローまたはアンダーフローが発生します。
これはエラーとはみなされません。
関連項目:
* [`toInt256`](#toInt256).
* [`toInt256OrZero`](#toInt256OrZero).
* [`toInt256OrDefault`](#toInt256OrDefault).
**構文**
```sql theme={null}
toInt256OrNull(x)
```
**引数**
* `x` — 数値の文字列表現です。 [`String`](/ja/reference/data-types/string)
**戻り値**
`Int256` 型の値を返します。変換に失敗した場合は `NULL` を返します。 [`Int256`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt256OrNull('-256'),
toInt256OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt256OrNull('-256'): -256
toInt256OrNull('abc'): \N
```
## toInt256OrZero
導入バージョン: v20.8.0
入力値を型 [Int256](/ja/reference/data-types/int-uint) に変換しますが、エラーが発生した場合は `0` を返します。
[`toInt256`](#toInt256) と同様ですが、例外をスローする代わりに `0` を返します。
関連項目:
* [`toInt256`](#toInt256)。
* [`toInt256OrNull`](#toInt256OrNull)。
* [`toInt256OrDefault`](#toInt256OrDefault)。
**構文**
```sql theme={null}
toInt256OrZero(x)
```
**引数**
* `x` — 変換対象の入力値。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`Float*`](/ja/reference/data-types/float) または [`Decimal`](/ja/reference/data-types/decimal) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime)
**戻り値**
変換後の入力値を返します。変換に失敗した場合は `0` を返します。[`Int256`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toInt256OrZero('123')
```
```response title=Response theme={null}
123
```
**変換に失敗するとゼロを返します**
```sql title=Query theme={null}
SELECT toInt256OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt32
導入バージョン: v1.1.0
入力値を [`Int32`](/ja/reference/data-types/int-uint) 型の値に変換します。
エラーが発生した場合は例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` および `Inf` を含む、Float\* 型の値の文字列表現。
* 2進数および16進数の値の文字列表現。例: `SELECT toInt32('0xc0fe');`。
入力値が [Int32](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
例: `SELECT toInt32(2147483648) == -2147483648;`
この関数は [ゼロ方向への丸め](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero) を使用します。つまり、数値の小数点以下の桁を切り捨てます。
関連項目:
* [`toInt32OrZero`](#toInt32OrZero)。
* [`toInt32OrNull`](#toInt32OrNull)。
* [`toInt32OrDefault`](#toInt32OrDefault)。
**構文**
```sql theme={null}
toInt32(expr)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
32 ビットの整数値を返します。[`Int32`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt32(-32),
toInt32(-32.32),
toInt32('-32')
FORMAT Vertical
```
```response title=Response theme={null}
行 1:
──────
toInt32(-32): -32
toInt32(-32.32): -32
toInt32('-32'): -32
```
## toInt32OrDefault
導入バージョン: v21.11.0
[`toInt32`](#toInt32) と同様に、この関数は入力値を [Int32](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が指定されていない場合、エラー時には `0` が返されます。
**構文**
```sql theme={null}
toInt32OrDefault(expr[, default])
```
**Arguments**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string)、[`(U)Int*`](/ja/reference/data-types/int-uint)、または [`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返されるデフォルト値。[`Int32`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Int32 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Int32`](/ja/reference/data-types/int-uint)
**Examples**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toInt32OrDefault('-32', CAST('-1', 'Int32'))
```
```response title=Response theme={null}
-32
```
**変換の失敗**
```sql title=Query theme={null}
SELECT toInt32OrDefault('abc', CAST('-1', 'Int32'))
```
```response title=Response theme={null}
-1
```
## toInt32OrNull
導入バージョン: v1.1.0
[`toInt32`](#toInt32) と同様に、この関数は入力値を [Int32](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラー時には `NULL` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む Float\* 値の文字列表現。
* 2 進数および 16 進数の文字列表現。例: `SELECT toInt32OrNull('0xc0fe');`。
入力値が [Int32](/ja/reference/data-types/int-uint) の範囲内に収まらない場合、結果でオーバーフローまたはアンダーフローが発生します。
これはエラーとはみなされません。
関連項目:
* [`toInt32`](#toInt32)。
* [`toInt32OrZero`](#toInt32OrZero)。
* [`toInt32OrDefault`](#toInt32OrDefault)。
**構文**
```sql theme={null}
toInt32OrNull(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
`Int32` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`Int32`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt32OrNull('-32'),
toInt32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt32OrNull('-32'): -32
toInt32OrNull('abc'): \N
```
## toInt32OrZero
導入バージョン: v1.1.0
[`toInt32`](#toInt32) と同様に、この関数は入力値を [Int32](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `0` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`0` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2進数および16進数の値の文字列表現。例: `SELECT toInt32OrZero('0xc0fe');`。
入力値が [Int32](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果にオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toInt32`](#toInt32)。
* [`toInt32OrNull`](#toInt32OrNull)。
* [`toInt32OrDefault`](#toInt32OrDefault)。
**構文**
```sql theme={null}
toInt32OrZero(x)
```
**引数**
* `x` — 数値を表す文字列。[`String`](/ja/reference/data-types/string)
**戻り値**
型 Int32 の値を返します。変換に失敗した場合は `0` を返します。[`Int32`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt32OrZero('32'),
toInt32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt32OrZero('32'): 32
toInt32OrZero('abc'): 0
```
## toInt64
導入バージョン: v1.1.0
入力値を [`Int64`](/ja/reference/data-types/int-uint) 型の値に変換します。
エラーが発生した場合は例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` および `Inf` を含む、Float\* 型の値を表す文字列。
* 2進数および16進数の文字列表現。例: `SELECT toInt64('0xc0fe');`。
入力値が [Int64](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
例: `SELECT toInt64(9223372036854775808) == -9223372036854775808;`
この関数は [ゼロ方向への丸め](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero) を使用します。つまり、数値の小数部分を切り落とします。
関連項目:
* [`toInt64OrZero`](#toInt64OrZero)。
* [`toInt64OrNull`](#toInt64OrNull)。
* [`toInt64OrDefault`](#toInt64OrDefault)。
**構文**
```sql theme={null}
toInt64(expr)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。サポート対象: 型 (U)Int\* の値または文字列表現、型 Float\* の値。非対応: NaN および Inf を含む Float\* 値の文字列表現、2 進数および 16 進数の値の文字列表現。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
64 ビット整数値を返します。[`Int64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt64(-64),
toInt64(-64.64),
toInt64('-64')
FORMAT Vertical
```
```response title=Response theme={null}
行 1:
──────
toInt64(-64): -64
toInt64(-64.64): -64
toInt64('-64'): -64
```
## toInt64OrDefault
導入バージョン: v21.11.0
[`toInt64`](#toInt64) と同様に、この関数は入力値を [Int64](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が指定されていない場合、エラー時には `0` が返されます。
**構文**
```sql theme={null}
toInt64OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返されるデフォルト値。[`Int64`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は Int64 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Int64`](/ja/reference/data-types/int-uint)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toInt64OrDefault('-64', CAST('-1', 'Int64'))
```
```response title=Response theme={null}
-64
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toInt64OrDefault('abc', CAST('-1', 'Int64'))
```
```response title=Response theme={null}
-1
```
## toInt64OrNull
導入バージョン: v1.1.0
[`toInt64`](#toInt64) と同様に、この関数は入力値を [Int64](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2進数および16進数の値の文字列表現。例: `SELECT toInt64OrNull('0xc0fe');`。
入力値が [Int64](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果にオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toInt64`](#toInt64)。
* [`toInt64OrZero`](#toInt64OrZero)。
* [`toInt64OrDefault`](#toInt64OrDefault)。
**構文**
```sql theme={null}
toInt64OrNull(x)
```
**引数**
* `x` — 数値を表す文字列。[`String`](/ja/reference/data-types/string)
**戻り値**
`Int64` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`Int64`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt64OrNull('-64'),
toInt64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt64OrNull('-64'): -64
toInt64OrNull('abc'): \N
```
## toInt64OrZero
導入バージョン: v1.1.0
入力値を [Int64](/ja/reference/data-types/int-uint) 型に変換します。エラーが発生した場合は `0` を返します。
[`toInt64`](#toInt64) と同様ですが、例外をスローする代わりに `0` を返します。
関連項目:
* [`toInt64`](#toInt64)。
* [`toInt64OrNull`](#toInt64OrNull)。
* [`toInt64OrDefault`](#toInt64OrDefault)。
**構文**
```sql theme={null}
toInt64OrZero(x)
```
**引数**
* `x` — 変換対象の入力値。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`Float*`](/ja/reference/data-types/float) または [`Decimal`](/ja/reference/data-types/decimal) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime)
**戻り値**
変換後の入力値を返します。変換に失敗した場合は `0` を返します。[`Int64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toInt64OrZero('123')
```
```response title=Response theme={null}
123
```
**変換に失敗した場合、ゼロを返します**
```sql title=Query theme={null}
SELECT toInt64OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt8
導入バージョン: v1.1.0
入力値を [`Int8`](/ja/reference/data-types/int-uint) 型の値に変換します。
エラー時には例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` および `Inf` を含む、Float\* 型の値の文字列表現。
* 2 進数および 16 進数の値の文字列表現。例: `SELECT toInt8('0xc0fe');`。
入力値が [Int8](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
例: `SELECT toInt8(128) == -128;`。
この関数は [ゼロ方向への丸め](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero) を使用します。つまり、数値の小数点以下の桁数を切り捨てます。
関連項目:
* [`toInt8OrZero`](#toInt8OrZero)。
* [`toInt8OrNull`](#toInt8OrNull)。
* [`toInt8OrDefault`](#toInt8OrDefault)。
**構文**
```sql theme={null}
toInt8(expr)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
8ビット整数値を返します。[`Int8`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt8(-8),
toInt8(-8.8),
toInt8('-8')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt8(-8): -8
toInt8(-8.8): -8
toInt8('-8'): -8
```
## toInt8OrDefault
導入バージョン: v21.11.0
[`toInt8`](#toInt8) と同様に、この関数は入力値を [Int8](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が指定されていない場合、エラー時には `0` が返されます。
**構文**
```sql theme={null}
toInt8OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返すデフォルト値。[`Int8`](/ja/reference/data-types/int-uint)
**戻り値**
変換に成功した場合は Int8 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`Int8`](/ja/reference/data-types/int-uint)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toInt8OrDefault('-8', CAST('-1', 'Int8'))
```
```response title=Response theme={null}
-8
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toInt8OrDefault('abc', CAST('-1', 'Int8'))
```
```response title=Response theme={null}
-1
```
## toInt8OrNull
導入バージョン: v1.1.0
[`toInt8`](#toInt8) と同様に、この関数は入力値を [Int8](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2進数および16進数の文字列表現。例: `SELECT toInt8OrNull('0xc0fe');`。
入力値が [Int8](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toInt8`](#toInt8)。
* [`toInt8OrZero`](#toInt8OrZero)。
* [`toInt8OrDefault`](#toInt8OrDefault)。
**構文**
```sql theme={null}
toInt8OrNull(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
`Int8` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`Int8`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt8OrNull('-8'),
toInt8OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt8OrNull('-8'): -8
toInt8OrNull('abc'): \N
```
## toInt8OrZero
導入バージョン: v1.1.0
[`toInt8`](#toInt8) と同様に、この関数は入力値を [Int8](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `0` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされていない引数 (`0` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2 進数および 16 進数の文字列表現。例: `SELECT toInt8OrZero('0xc0fe');`。
入力値が [Int8](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果としてオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toInt8`](#toInt8)。
* [`toInt8OrNull`](#toInt8OrNull)。
* [`toInt8OrDefault`](#toInt8OrDefault)。
**構文**
```sql theme={null}
toInt8OrZero(x)
```
**引数**
* `x` — 数値の文字列表現です。[`String`](/ja/reference/data-types/string)
**戻り値**
Int8 型の値を返します。変換に失敗した場合は `0` を返します。[`Int8`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toInt8OrZero('8'),
toInt8OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
行 1:
──────
toInt8OrZero('8'): 8
toInt8OrZero('abc'): 0
```
## toInterval
導入バージョン: v25.4.0
数値と単位を表す文字列から Interval 値を作成します。
この関数では、単位を文字列の引数として指定することで、1 つの関数から異なる型のインターバル (秒、分、時間、日、週、月、四半期、年) を統一的に作成できます。単位文字列では大文字と小文字は区別されません。
これは `toIntervalSecond`、`toIntervalMinute`、`toIntervalDay` などの型ごとの関数を呼び出すのと同等ですが、
単位を文字列パラメーターとして動的に指定できます。
**構文**
```sql theme={null}
toInterval(value, unit)
```
**引数**
* `value` — 単位数を表す数値です。任意の数値型を指定できます。 [`Int8`](/ja/reference/data-types/int-uint) or [`Int16`](/ja/reference/data-types/int-uint) or [`Int32`](/ja/reference/data-types/int-uint) or [`Int64`](/ja/reference/data-types/int-uint) or [`UInt8`](/ja/reference/data-types/int-uint) or [`UInt16`](/ja/reference/data-types/int-uint) or [`UInt32`](/ja/reference/data-types/int-uint) or [`UInt64`](/ja/reference/data-types/int-uint) or [`Float32`](/ja/reference/data-types/float) or [`Float64`](/ja/reference/data-types/float)
* `unit` — 時間の単位です。定数文字列である必要があります。有効な値は次のとおりです: 'nanosecond', 'microsecond', 'millisecond', 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'。 [`String`](/ja/reference/data-types/string)
**戻り値**
指定した型のInterval値を返します。結果の型は単位に応じて、IntervalNanosecond、IntervalMicrosecond、IntervalMillisecond、IntervalSecond、IntervalMinute、IntervalHour、IntervalDay、IntervalWeek、IntervalMonth、IntervalQuarter、またはIntervalYearになります。 [`Interval`](/ja/reference/data-types/int-uint)
**例**
**異なる単位のインターバルを作成する**
```sql title=Query theme={null}
SELECT
toInterval(5, 'second') AS seconds,
toInterval(3, 'day') AS days,
toInterval(2, 'month') AS months
```
```response title=Response theme={null}
┌─seconds─┬─days─┬─months─┐
│ 5 │ 3 │ 2 │
└─────────┴──────┴────────┘
```
**日付演算でインターバルを使用する**
```sql title=Query theme={null}
SELECT
now() AS current_time,
now() + toInterval(1, 'hour') AS one_hour_later,
now() - toInterval(7, 'day') AS week_ago
```
```response title=Response theme={null}
┌─────────current_time─┬──one_hour_later─────┬────────────week_ago─┐
│ 2025-01-04 10:30:00 │ 2025-01-04 11:30:00 │ 2024-12-28 10:30:00 │
└──────────────────────┴─────────────────────┴─────────────────────┘
```
**動的な interval の生成**
```sql title=Query theme={null}
SELECT toDate('2025-01-01') + toInterval(number, 'day') AS dates
FROM numbers(5)
```
```response title=Response theme={null}
┌──────dates─┐
│ 2025-01-01 │
│ 2025-01-02 │
│ 2025-01-03 │
│ 2025-01-04 │
│ 2025-01-05 │
└────────────┘
```
## toIntervalDay
導入バージョン: v1.1.0
データ型 [`IntervalDay`](/ja/reference/data-types/special-data-types/interval) の `n` 日間の インターバル を返します。
**構文**
```sql theme={null}
toIntervalDay(n)
```
**引数**
* `n` — 日数。整数またはその文字列表現、ならびに浮動小数点数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` 日の Interval を返します。[`Interval`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalDay(5) AS interval_to_days
SELECT date + interval_to_days AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-06-20 │
└────────────┘
```
## toIntervalHour
導入バージョン: v1.1.0
データ型 [`IntervalHour`](/ja/reference/data-types/special-data-types/interval) の、`n` 時間を表す インターバル を返します。
**構文**
```sql theme={null}
toIntervalHour(n)
```
**引数**
* `n` — 時間数。整数またはその文字列表現、および浮動小数点数。[`Int*`](/ja/reference/data-types/int-uint) または [`UInt*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` 時間の `インターバル` を返します。[`Interval`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalHour(12) AS interval_to_hours
SELECT date + interval_to_hours AS result
```
```response title=Response theme={null}
┌──────────────result─┐
│ 2025-06-15 12:00:00 │
└─────────────────────┘
```
## toIntervalMicrosecond
導入バージョン: v22.6.0
データ型 [`IntervalMicrosecond`](/ja/reference/data-types/special-data-types/interval) の、`n` マイクロ秒を表す インターバル を返します。
**構文**
```sql theme={null}
toIntervalMicrosecond(n)
```
**引数**
* `n` — マイクロ秒数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` マイクロ秒を表す インターバル を返します。[`Interval`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDateTime('2025-06-15') AS date,
toIntervalMicrosecond(30) AS interval_to_microseconds
SELECT date + interval_to_microseconds AS result
```
```response title=Response theme={null}
┌─────────────────────result─┐
│ 2025-06-15 00:00:00.000030 │
└────────────────────────────┘
```
## toIntervalMillisecond
導入バージョン: v22.6.0
データ型 [IntervalMillisecond](/ja/reference/data-types/special-data-types/interval) の `n` ミリ秒のインターバルを返します。
**構文**
```sql theme={null}
toIntervalMillisecond(n)
```
**引数**
* `n` — ミリ秒数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` ミリ秒の `Interval` を返します。[`Interval`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDateTime('2025-06-15') AS date,
toIntervalMillisecond(30) AS interval_to_milliseconds
SELECT date + interval_to_milliseconds AS result
```
```response title=Response theme={null}
┌──────────────────result─┐
│ 2025-06-15 00:00:00.030 │
└─────────────────────────┘
```
## toIntervalMinute
導入バージョン: v1.1.0
`n` 分を表す、データ型 [`IntervalMinute`](/ja/reference/data-types/special-data-types/interval) の interval を返します。
**構文**
```sql theme={null}
toIntervalMinute(n)
```
**引数**
* `n` — 分単位の数値。整数またはその文字列表現、および浮動小数点数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` 分の interval を返します。[`インターバル`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalMinute(12) AS interval_to_minutes
SELECT date + interval_to_minutes AS result
```
```response title=Response theme={null}
┌──────────────result─┐
│ 2025-06-15 00:12:00 │
└─────────────────────┘
```
## toIntervalMonth
導入バージョン: v1.1.0
データ型 [`IntervalMonth`](/ja/reference/data-types/special-data-types/interval) の `n` か月のインターバルを返します。
**構文**
```sql theme={null}
toIntervalMonth(n)
```
**引数**
* `n` — 月数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` か月の [`Interval`](/ja/reference/data-types/int-uint) を返します。
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalMonth(1) AS interval_to_month
SELECT date + interval_to_month AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-07-15 │
└────────────┘
```
## toIntervalNanosecond
導入バージョン: v22.6.0
データ型 [`IntervalNanosecond`](/ja/reference/data-types/special-data-types/interval) の、`n` ナノ秒を表す interval を返します。
**構文**
```sql theme={null}
toIntervalNanosecond(n)
```
**引数**
* `n` — ナノ秒数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` ナノ秒の [`インターバル`](/ja/reference/data-types/int-uint) を返します。
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDateTime('2025-06-15') AS date,
toIntervalNanosecond(30) AS interval_to_nanoseconds
SELECT date + interval_to_nanoseconds AS result
```
```response title=Response theme={null}
┌────────────────────────result─┐
│ 2025-06-15 00:00:00.000000030 │
└───────────────────────────────┘
```
## toIntervalQuarter
導入バージョン: v1.1.0
データ型 [`IntervalQuarter`](/ja/reference/data-types/special-data-types/interval) の `n` 四半期の interval 値を返します。
**構文**
```sql theme={null}
toIntervalQuarter(n)
```
**引数**
* `n` — 四半期の数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` 四半期を表す interval を返します。[`インターバル`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalQuarter(1) AS interval_to_quarter
SELECT date + interval_to_quarter AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-09-15 │
└────────────┘
```
## toIntervalSecond
導入バージョン: v1.1.0
データ型[`IntervalSecond`](/ja/reference/data-types/special-data-types/interval)の`n`秒のインターバルを返します。
**構文**
```sql theme={null}
toIntervalSecond(n)
```
**引数**
* `n` — 秒数。整数、整数の文字列表現、または浮動小数点数。 [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` 秒の [`Interval`](/ja/reference/data-types/int-uint) を返します。
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalSecond(30) AS interval_to_seconds
SELECT date + interval_to_seconds AS result
```
```response title=Response theme={null}
┌──────────────result─┐
│ 2025-06-15 00:00:30 │
└─────────────────────┘
```
## toIntervalWeek
導入バージョン: v1.1.0
データ型 [`IntervalWeek`](/ja/reference/data-types/special-data-types/interval) の `n` 週間のインターバルを返します。
**構文**
```sql theme={null}
toIntervalWeek(n)
```
**引数**
* `n` — 週数。[`(U)Int*`](/ja/reference/data-types/int-uint)、[`Float*`](/ja/reference/data-types/float)、または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` 週間の インターバル を返します。[`Interval`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalWeek(1) AS interval_to_week
SELECT date + interval_to_week AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-06-22 │
└────────────┘
```
## toIntervalYear
導入バージョン: v1.1.0
データ型[`IntervalYear`](/ja/reference/data-types/special-data-types/interval)の、`n` 年を表す interval 値を返します。
**構文**
```sql theme={null}
toIntervalYear(n)
```
**引数**
* `n` — 年数。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string)
**戻り値**
`n` 年の期間を表す [`インターバル`](/ja/reference/data-types/int-uint) を返します。
**例**
**使用例**
```sql title=Query theme={null}
WITH
toDate('2024-06-15') AS date,
toIntervalYear(1) AS interval_to_year
SELECT date + interval_to_year AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-06-15 │
└────────────┘
```
## toLowCardinality
導入バージョン: v18.12.0
入力引数を、同じデータ型の[LowCardinality](/ja/reference/data-types/lowcardinality)版に変換します。
`LowCardinality` データ型から通常のデータ型に変換するには、[CAST](#CAST) 関数を使用します。
例: `CAST(x AS String)`。
**構文**
```sql theme={null}
toLowCardinality(expr)
```
**引数**
* `expr` — サポートされているデータ型のいずれかを返す式。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`Date`](/ja/reference/data-types/date) または [`DateTime`](/ja/reference/data-types/datetime) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
**戻り値**
入力値を `LowCardinality` データ型に変換した結果を返します。[`LowCardinality`](/ja/reference/data-types/lowcardinality)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toLowCardinality('1')
```
```response title=Response theme={null}
┌─toLowCardinality('1')─┐
│ 1 │
└───────────────────────┘
```
## toString
導入バージョン: v1.1.0
値を文字列表現に変換します。
DateTime 引数の場合、この関数はタイムゾーン名を指定した 2 つ目の String 引数を取ることができます。
**構文**
```sql theme={null}
toString(value[, timezone])
```
**引数**
* `value` — 文字列に変換する値。[`Any`](/ja/reference/data-types/index)
* `timezone` — 省略可能。DateTime の変換に使用するタイムゾーン名。[`String`](/ja/reference/data-types/string)
**戻り値**
入力値の文字列表現を返します。[`String`](/ja/reference/data-types/string)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
now() AS ts,
time_zone,
toString(ts, time_zone) AS str_tz_datetime
FROM system.time_zones
WHERE time_zone LIKE 'Europe%'
LIMIT 10
```
```response title=Response theme={null}
┌──────────────────ts─┬─time_zone─────────┬─str_tz_datetime─────┐
│ 2023-09-08 19:14:59 │ Europe/Amsterdam │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Andorra │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Astrakhan │ 2023-09-08 23:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Athens │ 2023-09-08 22:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Belfast │ 2023-09-08 20:14:59 │
└─────────────────────┴───────────────────┴─────────────────────┘
```
## toStringCutToZero
導入バージョン: v1.1.0
[String](/ja/reference/data-types/string) または [FixedString](/ja/reference/data-types/fixedstring) 型の引数を受け取り、元の文字列を最初の null byte で切り詰めた String を返します。
null byte (\0) は文字列終端文字として扱われます。
この関数は、null byte が意味のある内容の終端を示す C 形式の文字列やバイナリデータの処理に役立ちます。
**構文**
```sql theme={null}
toStringCutToZero(s)
```
**引数**
* `s` — 処理対象の String または FixedString。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
最初のヌルバイトより前の文字を含む String を返します。[`String`](/ja/reference/data-types/string)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toStringCutToZero('hello'),
toStringCutToZero('hello\0world')
```
```response title=Response theme={null}
┌─toStringCutToZero('hello')─┬─toStringCutToZero('hello\\0world')─┐
│ hello │ hello │
└────────────────────────────┴───────────────────────────────────┘
```
## toTime
導入バージョン: v1.1.0
入力値を [Time](/ja/reference/data-types/time) 型に変換します。
String、FixedString、DateTime、または深夜0時からの経過秒数を表す数値型からの変換をサポートします。
**構文**
```sql theme={null}
toTime(x)
```
**引数**
* `x` — 変換対象の入力値。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`DateTime`](/ja/reference/data-types/datetime) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
**戻り値**
変換後の値を返します。[`Time`](/ja/reference/data-types/time)
**例**
**StringからTimeへの変換**
```sql title=Query theme={null}
SELECT toTime('14:30:25')
```
```response title=Response theme={null}
14:30:25
```
**DateTimeからTimeへの変換**
```sql title=Query theme={null}
SELECT toTime(toDateTime('2025-04-15 14:30:25'))
```
```response title=Response theme={null}
14:30:25
```
**整数からTimeへの変換**
```sql title=Query theme={null}
SELECT toTime(52225)
```
```response title=Response theme={null}
14:30:25
```
## toTime64
導入バージョン: v25.6.0
入力値を [Time64](/ja/reference/data-types/time64) 型に変換します。
String、FixedString、DateTime64、または午前0時からの経過時間をマイクロ秒で表した数値型からの変換をサポートします。
時刻値をマイクロ秒精度で表現できます。
**構文**
```sql theme={null}
toTime64(x)
```
**引数**
* `x` — 変換対象の入力値。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`DateTime64`](/ja/reference/data-types/datetime64) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
**戻り値**
入力値をマイクロ秒精度で変換した値を返します。[`Time64(6)`](/ja/reference/data-types/time64)
**例**
**String から Time64 への変換**
```sql title=Query theme={null}
SELECT toTime64('14:30:25.123456')
```
```response title=Response theme={null}
14:30:25.123456
```
**DateTime64 から Time64 への変換**
```sql title=Query theme={null}
SELECT toTime64(toDateTime64('2025-04-15 14:30:25.123456', 6))
```
```response title=Response theme={null}
14:30:25.123456
```
**整数型から Time64 への変換**
```sql title=Query theme={null}
SELECT toTime64(52225123456)
```
```response title=Response theme={null}
14:30:25.123456
```
## toTime64OrNull
導入バージョン: v25.6.0
入力値を `Time64` 型の値に変換します。エラーが発生した場合は `NULL` を返します。
[`toTime64`](#toTime64) と同様ですが、変換エラー時には例外をスローせず、`NULL` を返します。
関連項目:
* [`toTime64`](#toTime64)
* [`toTime64OrZero`](#toTime64OrZero)
**構文**
```sql theme={null}
toTime64OrNull(x)
```
**引数**
* `x` — 秒未満の精度を含む時刻の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は `Time64` 値を返し、失敗した場合は `NULL` を返します。[`Time64`](/ja/reference/data-types/time64) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toTime64OrNull('12:30:45.123'), toTime64OrNull('invalid')
```
```response title=Response theme={null}
┌─toTime64OrNull('12:30:45.123')─┬─toTime64OrNull('invalid')─┐
│ 12:30:45.123 │ ᴺᵁᴸᴸ │
└────────────────────────────────┴───────────────────────────┘
```
## toTime64OrZero
導入バージョン: v25.6.0
入力値を Time64 型の値に変換しますが、エラーが発生した場合は `00:00:00.000` を返します。
[`toTime64`](#toTime64) と同様ですが、変換エラー時には例外をスローせず、代わりに `00:00:00.000` を返します。
**構文**
```sql theme={null}
toTime64OrZero(x)
```
**引数**
* `x` — 秒未満の精度を含む時刻の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は Time64 値を返し、失敗した場合は `00:00:00.000` を返します。[`Time64`](/ja/reference/data-types/time64)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toTime64OrZero('12:30:45.123'), toTime64OrZero('invalid')
```
```response title=Response theme={null}
┌─toTime64OrZero('12:30:45.123')─┬─toTime64OrZero('invalid')─┐
│ 12:30:45.123 │ 00:00:00.000 │
└────────────────────────────────┴──────────────────────────┘
```
## toTimeOrNull
導入バージョン: v1.1.0
入力値を Time 型の値に変換します。エラーが発生した場合は `NULL` を返します。
[`toTime`](#toTime) と同様ですが、変換エラー時に例外をスローする代わりに `NULL` を返します。
関連項目:
* [`toTime`](#toTime)
* [`toTimeOrZero`](#toTimeOrZero)
**構文**
```sql theme={null}
toTimeOrNull(x)
```
**引数**
* `x` — 時刻を表す文字列。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は `Time` 型の値を返し、失敗した場合は `NULL` を返します。[`Time`](/ja/reference/data-types/time) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toTimeOrNull('12:30:45'), toTimeOrNull('invalid')
```
```response title=Response theme={null}
┌─toTimeOrNull('12:30:45')─┬─toTimeOrNull('invalid')─┐
│ 12:30:45 │ ᴺᵁᴸᴸ │
└──────────────────────────┴─────────────────────────┘
```
## toTimeOrZero
導入バージョン: v1.1.0
入力値を Time 型の値に変換します。エラーが発生した場合は `00:00:00` を返します。
`toTime` と同様ですが、変換エラー時に例外をスローする代わりに `00:00:00` を返します。
**構文**
```sql theme={null}
toTimeOrZero(x)
```
**引数**
* `x` — 時刻を表す文字列。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は `Time` 型の値を返し、それ以外の場合は `00:00:00` を返します。[`Time`](/ja/reference/data-types/time)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toTimeOrZero('12:30:45'), toTimeOrZero('invalid')
```
```response title=Response theme={null}
┌─toTimeOrZero('12:30:45')─┬─toTimeOrZero('invalid')─┐
│ 12:30:45 │ 00:00:00 │
└──────────────────────────┴─────────────────────────┘
```
## toUInt128
導入バージョン: v1.1.0
入力値を [`UInt128`](/ja/reference/functions/regular-functions/type-conversion-functions#toUInt128) 型の値に変換します。
エラーが発生した場合は例外をスローします。
この関数ではゼロ方向への丸めが使用されるため、数値の小数点以下の桁は切り捨てられます。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` および `Inf` を含む、Float\* 型の値の文字列表現。
* 2 進数および 16 進数の値の文字列表現。例: `SELECT toUInt128('0xc0fe');`。
入力値を UInt128 の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toUInt128OrZero`](#toUInt128OrZero)。
* [`toUInt128OrNull`](#toUInt128OrNull)。
* [`toUInt128OrDefault`](#toUInt128OrDefault)。
**構文**
```sql theme={null}
toUInt128(expr)
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
128ビットの符号なし整数値を返します。[`UInt128`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt128(128),
toUInt128(128.8),
toUInt128('128')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt128(128): 128
toUInt128(128.8): 128
toUInt128('128'): 128
```
## toUInt128OrDefault
導入バージョン: v21.11.0
[`toUInt128`](#toUInt128) と同様に、この関数は入力値を [`UInt128`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が指定されていない場合、エラー時には `0` が返されます。
**構文**
```sql theme={null}
toUInt128OrDefault(expr[, default])
```
**Arguments**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 省略可能。パースに失敗した場合に返すデフォルト値。[`UInt128`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は UInt128 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`UInt128`](/ja/reference/data-types/int-uint)
**Examples**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toUInt128OrDefault('128', CAST('0', 'UInt128'))
```
```response title=Response theme={null}
128
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toUInt128OrDefault('abc', CAST('0', 'UInt128'))
```
```response title=Response theme={null}
0
```
## toUInt128OrNull
導入バージョン: v21.6.0
[`toUInt128`](#toUInt128) と同様に、この関数は入力値を [`UInt128`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* バイナリ値および 16 進数値の文字列表現。例: `SELECT toUInt128OrNull('0xc0fe');`。
入力値が [`UInt128`](/ja/reference/data-types/int-uint) の範囲内に収まらない場合、結果でオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toUInt128`](#toUInt128)。
* [`toUInt128OrZero`](#toUInt128OrZero)。
* [`toUInt128OrDefault`](#toUInt128OrDefault)。
**構文**
```sql theme={null}
toUInt128OrNull(x)
```
**引数**
* `x` — 数値を表す文字列です。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt128` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`UInt128`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt128OrNull('128'),
toUInt128OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt128OrNull('128'): 128
toUInt128OrNull('abc'): \N
```
## toUInt128OrZero
導入バージョン: v1.1.0
[`toUInt128`](#toUInt128) と同様に、この関数は入力値を [`UInt128`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラー時には `0` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`0` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* バイナリ値および16進数値の文字列表現。例: `SELECT toUInt128OrZero('0xc0fe');`。
入力値が [`UInt128`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toUInt128`](#toUInt128)。
* [`toUInt128OrNull`](#toUInt128OrNull)。
* [`toUInt128OrDefault`](#toUInt128OrDefault)。
**構文**
```sql theme={null}
toUInt128OrZero(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt128` 型の値を返します。変換に失敗した場合は `0` を返します。[`UInt128`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt128OrZero('128'),
toUInt128OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt128OrZero('128'): 128
toUInt128OrZero('abc'): 0
```
## toUInt16
導入バージョン: v1.1.0
入力値を[`UInt16`](/ja/reference/data-types/int-uint)型の値に変換します。
エラーが発生した場合は例外をスローします。
対応する引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
対応していない引数:
* `NaN` や `Inf` を含む、Float\* 型の値の文字列表現。
* バイナリ値や16進値の文字列表現。例: `SELECT toUInt16('0xc0fe');`。
入力値が[`UInt16`](/ja/reference/data-types/int-uint)の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
例: `SELECT toUInt16(65536) == 0;`。
この関数は[ゼロ方向への丸め](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero)を使用します。つまり、数値の小数点以下の桁を切り捨てます。
関連項目:
* [`toUInt16OrZero`](#toUInt16OrZero)。
* [`toUInt16OrNull`](#toUInt16OrNull)。
* [`toUInt16OrDefault`](#toUInt16OrDefault)。
**構文**
```sql theme={null}
toUInt16(expr)
```
**引数**
* `expr` — 数値、またはその文字列表現を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
16 ビットの符号なし整数値を返します。[`UInt16`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt16(16),
toUInt16(16.16),
toUInt16('16')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt16(16): 16
toUInt16(16.16): 16
toUInt16('16'): 16
```
## toUInt16OrDefault
導入バージョン: v21.11.0
[`toUInt16`](#toUInt16) と同様に、この関数は入力値を [UInt16](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が渡されない場合は、エラー時に `0` が返されます。
**構文**
```sql theme={null}
toUInt16OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string)、[`(U)Int*`](/ja/reference/data-types/int-uint)、[`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返すデフォルト値。[`UInt16`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は UInt16 型の値を返します。失敗した場合は、`default` が指定されていればその値を、指定されていなければ 0 を返します。[`UInt16`](/ja/reference/data-types/int-uint)
**例**
**変換が成功した場合**
```sql title=Query theme={null}
SELECT toUInt16OrDefault('16', CAST('0', 'UInt16'))
```
```response title=Response theme={null}
16
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toUInt16OrDefault('abc', CAST('0', 'UInt16'))
```
```response title=Response theme={null}
0
```
## toUInt16OrNull
導入バージョン: v1.1.0
[`toUInt16`](#toUInt16) と同様に、この関数は入力値を [`UInt16`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
サポートされる引数:
* (U)Int8/16/32/128/256 の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む Float\* 型の値の文字列表現。
* 2進数値および16進数値の文字列表現。例: `SELECT toUInt16OrNull('0xc0fe');`。
入力値が [`UInt16`](/ja/reference/data-types/int-uint) の範囲内に収まらない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toUInt16`](#toUInt16)。
* [`toUInt16OrZero`](#toUInt16OrZero)。
* [`toUInt16OrDefault`](#toUInt16OrDefault)。
**構文**
```sql theme={null}
toUInt16OrNull(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt16` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`UInt16`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt16OrNull('16'),
toUInt16OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt16OrNull('16'): 16
toUInt16OrNull('abc'): \N
```
## toUInt16OrZero
導入バージョン: v1.1.0
[`toUInt16`](#toUInt16) と同様に、この関数は入力値を [`UInt16`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `0` を返します。
サポートされる引数:
* (U)Int8/16/32/128/256 の文字列表現。
サポートされない引数 (`0` を返します):
* `NaN` および `Inf` を含む Float\* 値の文字列表現。
* 2進数値および16進数値の文字列表現。例: `SELECT toUInt16OrZero('0xc0fe');`。
入力値が [`UInt16`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果でオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toUInt16`](#toUInt16)。
* [`toUInt16OrNull`](#toUInt16OrNull)。
* [`toUInt16OrDefault`](#toUInt16OrDefault)。
**構文**
```sql theme={null}
toUInt16OrZero(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
UInt16 型の値を返します。変換に失敗した場合は `0` を返します。[`UInt16`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt16OrZero('16'),
toUInt16OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt16OrZero('16'): 16
toUInt16OrZero('abc'): 0
```
## toUInt256
導入バージョン: v1.1.0
入力値を UInt256 型の値に変換します。
エラー時には例外をスローします。
この関数ではゼロ方向への丸めを使用するため、数値の小数点以下の桁数は切り捨てられます。
サポートされる引数:
* (U)Int\* 型の値またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2進数値および16進数値の文字列表現 (例: `SELECT toUInt256('0xc0fe');`) 。
入力値を UInt256 の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrNull`](#toUInt256OrNull).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**構文**
```sql theme={null}
toUInt256(expr)
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
256 ビットの符号なし整数値を返します。[`UInt256`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt256(256),
toUInt256(256.256),
toUInt256('256')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt256(256): 256
toUInt256(256.256): 256
toUInt256('256'): 256
```
## toUInt256OrDefault
導入バージョン: v21.11.0
[`toUInt256`](#toUInt256) と同様に、この関数は入力値を [UInt256](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が渡されていない場合、エラー時には `0` が返されます。
**構文**
```sql theme={null}
toUInt256OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返されるデフォルト値。[`UInt256`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は UInt256 型の値を返します。失敗した場合は、`default` が指定されていればその値を、指定されていなければ 0 を返します。[`UInt256`](/ja/reference/data-types/int-uint)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toUInt256OrDefault('-256', CAST('0', 'UInt256'))
```
```response title=Response theme={null}
0
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toUInt256OrDefault('abc', CAST('0', 'UInt256'))
```
```response title=Response theme={null}
0
```
## toUInt256OrNull
導入バージョン: v20.8.0
[`toUInt256`](#toUInt256) と同様に、この関数は入力値を [`UInt256`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2 進数値および 16 進数値の文字列表現。例: `SELECT toUInt256OrNull('0xc0fe');`。
入力値が [`UInt256`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toUInt256`](#toUInt256).
* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**構文**
```sql theme={null}
toUInt256OrNull(x)
```
**引数**
* `x` — 数値を表す文字列。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt256` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`UInt256`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt256OrNull('256'),
toUInt256OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt256OrNull('256'): 256
toUInt256OrNull('abc'): \N
```
## toUInt256OrZero
導入バージョン: v20.8.0
[`toUInt256`](#toUInt256) と同様に、この関数は入力値を [`UInt256`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `0` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`0` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2進数値および16進数値の文字列表現。例: `SELECT toUInt256OrZero('0xc0fe');`。
入力値が [`UInt256`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果でオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toUInt256`](#toUInt256)。
* [`toUInt256OrNull`](#toUInt256OrNull)。
* [`toUInt256OrDefault`](#toUInt256OrDefault)。
**構文**
```sql theme={null}
toUInt256OrZero(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
型が UInt256 の値を返します。変換に失敗した場合は `0` を返します。[`UInt256`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt256OrZero('256'),
toUInt256OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt256OrZero('256'): 256
toUInt256OrZero('abc'): 0
```
## toUInt32
導入バージョン: v1.1.0
入力値を [`UInt32`](/ja/reference/data-types/int-uint) 型の値に変換します。
エラーが発生した場合は例外がスローされます。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` および `Inf` を含む、Float\* 型の値の文字列表現。
* 2進数値および16進数値の文字列表現。例: `SELECT toUInt32('0xc0fe');`
入力値が [`UInt32`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとはみなされません。
例: `SELECT toUInt32(4294967296) == 0;`
この関数は [ゼロ方向への丸め](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero) を使用します。つまり、数値の小数点以下を切り捨てます。
関連項目:
* [`toUInt32OrZero`](#toUInt32OrZero).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**構文**
```sql theme={null}
toUInt32(expr)
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
32 ビットの符号なし整数値を返します。[`UInt32`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt32(32),
toUInt32(32.32),
toUInt32('32')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt32(32): 32
toUInt32(32.32): 32
toUInt32('32'): 32
```
## toUInt32OrDefault
導入バージョン: v21.11.0
[`toUInt32`](#toUInt32) と同様に、この関数は入力値を [UInt32](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が指定されていない場合、エラー時には `0` が返されます。
**構文**
```sql theme={null}
toUInt32OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 省略可。パースに失敗した場合に返されるデフォルト値。[`UInt32`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は UInt32 型の値を返します。失敗した場合は、`default` が渡されていればその値を、渡されていなければ 0 を返します。[`UInt32`](/ja/reference/data-types/int-uint)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toUInt32OrDefault('32', CAST('0', 'UInt32'))
```
```response title=Response theme={null}
32
```
**変換失敗**
```sql title=Query theme={null}
SELECT toUInt32OrDefault('abc', CAST('0', 'UInt32'))
```
```response title=Response theme={null}
0
```
## toUInt32OrNull
導入バージョン: v1.1.0
[`toUInt32`](#toUInt32) と同様に、この関数は入力値を [`UInt32`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラー時には `NULL` を返します。
サポートされる引数:
* (U)Int8/16/32/128/256 の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む Float\* 値の文字列表現。
* 2進数値および16進数値の文字列表現。例: `SELECT toUInt32OrNull('0xc0fe');`。
入力値を [`UInt32`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果にオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toUInt32`](#toUInt32)。
* [`toUInt32OrZero`](#toUInt32OrZero)。
* [`toUInt32OrDefault`](#toUInt32OrDefault)。
**構文**
```sql theme={null}
toUInt32OrNull(x)
```
**引数**
* `x` — 数値を表す `String` です。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt32` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`UInt32`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt32OrNull('32'),
toUInt32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt32OrNull('32'): 32
toUInt32OrNull('abc'): \N
```
## toUInt32OrZero
導入バージョン: v1.1.0
[`toUInt32`](#toUInt32) と同様に、この関数は入力値を [`UInt32`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `0` を返します。
サポートされる引数:
* (U)Int8/16/32/128/256 の文字列表現。
サポートされない引数 (`0` を返します):
* `NaN` および `Inf` を含む Float\* 値の文字列表現。
* 2進数値および16進数値の文字列表現。例: `SELECT toUInt32OrZero('0xc0fe');`。
入力値が [`UInt32`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toUInt32`](#toUInt32).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**構文**
```sql theme={null}
toUInt32OrZero(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt32` 型の値を返します。変換に失敗した場合は `0` を返します。[`UInt32`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt32OrZero('32'),
toUInt32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
行 1:
──────
toUInt32OrZero('32'): 32
toUInt32OrZero('abc'): 0
```
## toUInt64
導入バージョン: v1.1.0
入力値を [`UInt64`](/ja/reference/data-types/int-uint) 型の値に変換します。
エラーが発生した場合は例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない型:
* `NaN` と `Inf` を含む、Float\* 型の値の文字列表現。
* 2進数値および16進数値の文字列表現 (例: `SELECT toUInt64('0xc0fe');`) 。
入力値が [`UInt64`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
例: `SELECT toUInt64(18446744073709551616) == 0;`
この関数は [ゼロ方向への丸め](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero) を使用します。つまり、数値の小数点以下の桁を切り捨てます。
関連項目:
* [`toUInt64OrZero`](#toUInt64OrZero)。
* [`toUInt64OrNull`](#toUInt64OrNull)。
* [`toUInt64OrDefault`](#toUInt64OrDefault)。
**構文**
```sql theme={null}
toUInt64(expr)
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`式`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
64 ビットの符号なし整数値を返します。[`UInt64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt64(64),
toUInt64(64.64),
toUInt64('64')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt64(64): 64
toUInt64(64.64): 64
toUInt64('64'): 64
```
## toUInt64OrDefault
導入バージョン: v21.11.0
[`toUInt64`](#toUInt64) と同様に、この関数は入力値を [UInt64](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` が渡されない場合、エラーが発生したときは `0` が返されます。
**構文**
```sql theme={null}
toUInt64OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 省略可能。パースに失敗した場合に返すデフォルト値。[`UInt64`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は UInt64 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`UInt64`](/ja/reference/data-types/int-uint)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toUInt64OrDefault('64', CAST('0', 'UInt64'))
```
```response title=Response theme={null}
64
```
**変換に失敗**
```sql title=Query theme={null}
SELECT toUInt64OrDefault('abc', CAST('0', 'UInt64'))
```
```response title=Response theme={null}
0
```
## toUInt64OrNull
導入バージョン: v1.1.0
[`toUInt64`](#toUInt64) と同様に、この関数は入力値を [`UInt64`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラー時には `NULL` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`NULL` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2進数値および16進数値の文字列表現。例: `SELECT toUInt64OrNull('0xc0fe');`。
入力値を [`UInt64`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果でオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toUInt64`](#toUInt64)。
* [`toUInt64OrZero`](#toUInt64OrZero)。
* [`toUInt64OrDefault`](#toUInt64OrDefault)。
**構文**
```sql theme={null}
toUInt64OrNull(x)
```
**引数**
* `x` — 数値を表す文字列。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt64` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`UInt64`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt64OrNull('64'),
toUInt64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt64OrNull('64'): 64
toUInt64OrNull('abc'): \N
```
## toUInt64OrZero
導入バージョン: v1.1.0
[`toUInt64`](#toUInt64) と同様に、この関数は入力値を [`UInt64`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `0` を返します。
サポートされる引数:
* (U)Int\* の文字列表現。
サポートされない引数 (`0` を返します) :
* `NaN` および `Inf` を含む、Float\* 値の文字列表現。
* 2進数および16進数の値の文字列表現。例: `SELECT toUInt64OrZero('0xc0fe');`。
入力値が [`UInt64`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果としてオーバーフローまたはアンダーフローが発生します。
これはエラーとは見なされません。
関連項目:
* [`toUInt64`](#toUInt64)。
* [`toUInt64OrNull`](#toUInt64OrNull)。
* [`toUInt64OrDefault`](#toUInt64OrDefault)。
**構文**
```sql theme={null}
toUInt64OrZero(x)
```
**引数**
* `x` — 数値を表す文字列。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt64` 型の値を返します。変換に失敗した場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt64OrZero('64'),
toUInt64OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt64OrZero('64'): 64
toUInt64OrZero('abc'): 0
```
## toUInt8
導入バージョン: v1.1.0
入力値を [`UInt8`](/ja/reference/data-types/int-uint) 型の値に変換します。
エラーが発生した場合は例外をスローします。
サポートされる引数:
* (U)Int\* 型の値、またはその文字列表現。
* Float\* 型の値。
サポートされない引数:
* `NaN` および `Inf` を含む、Float\* 型の値の文字列表現。
* バイナリ値および16進数値の文字列表現。例: `SELECT toUInt8('0xc0fe');`。
入力値が [UInt8](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
例: `SELECT toUInt8(256) == 0;`。
この関数は [rounding towards zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero) を使用します。つまり、数値の小数点以下の桁を切り捨てます。
関連項目:
* [`toUInt8OrZero`](#toUInt8OrZero)。
* [`toUInt8OrNull`](#toUInt8OrNull)。
* [`toUInt8OrDefault`](#toUInt8OrDefault)。
**構文**
```sql theme={null}
toUInt8(expr)
```
**引数**
* `expr` — 数値、または数値を表す文字列を返す式。[`Expression`](/ja/reference/data-types/special-data-types/expression)
**戻り値**
8 ビットの符号なし整数値を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt8(8),
toUInt8(8.8),
toUInt8('8')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt8(8): 8
toUInt8(8.8): 8
toUInt8('8'): 8
```
## toUInt8OrDefault
導入バージョン: v21.11.0
[`toUInt8`](#toUInt8) と同様に、この関数は入力値を [UInt8](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合はデフォルト値を返します。
`default` 値が渡されない場合、エラー発生時には `0` が返されます。
**構文**
```sql theme={null}
toUInt8OrDefault(expr[, default])
```
**引数**
* `expr` — 数値、または数値の文字列表現を返す式。[`String`](/ja/reference/data-types/string) または [`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `default` — 任意。パースに失敗した場合に返すデフォルト値。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
成功した場合は UInt8 型の値を返します。失敗した場合は、指定されていればデフォルト値を、指定されていなければ 0 を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**変換に成功した場合**
```sql title=Query theme={null}
SELECT toUInt8OrDefault('8', CAST('0', 'UInt8'))
```
```response title=Response theme={null}
8
```
**変換に失敗した場合**
```sql title=Query theme={null}
SELECT toUInt8OrDefault('abc', CAST('0', 'UInt8'))
```
```response title=Response theme={null}
0
```
## toUInt8OrNull
導入バージョン: v1.1.0
[`toUInt8`](#toUInt8) と同様に、この関数は入力値を [`UInt8`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `NULL` を返します。
サポートされる引数:
* (U)Int8/16/32/128/256 の文字列表現。
サポートされない引数 (`NULL` を返します):
* `NaN` および `Inf` を含む、通常の Float\* 型の値の文字列表現。
* 2進数値および16進数値の文字列表現。例: `SELECT toUInt8OrNull('0xc0fe');`。
入力値を [`UInt8`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果のオーバーフローまたはアンダーフローが発生します。
これはエラーとはみなされません。
関連項目:
* [`toUInt8`](#toUInt8)。
* [`toUInt8OrZero`](#toUInt8OrZero)。
* [`toUInt8OrDefault`](#toUInt8OrDefault)。
**構文**
```sql theme={null}
toUInt8OrNull(x)
```
**引数**
* `x` — 数値を表す文字列。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt8` 型の値を返します。変換に失敗した場合は `NULL` を返します。[`UInt8`](/ja/reference/data-types/int-uint) または [`NULL`](/ja/reference/syntax#null)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt8OrNull('42'),
toUInt8OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt8OrNull('42'): 42
toUInt8OrNull('abc'): \N
```
## toUInt8OrZero
導入バージョン: v1.1.0
[`toUInt8`](#toUInt8) と同様に、この関数は入力値を [`UInt8`](/ja/reference/data-types/int-uint) 型の値に変換しますが、エラーが発生した場合は `0` を返します。
サポートされる引数:
* (U)Int8/16/32/128/256 の文字列表現。
サポートされない引数 (`0` を返します):
* `NaN` および `Inf` を含む、通常の Float\* 型の値の文字列表現。
* 2進数値および16進数値の文字列表現。例: `SELECT toUInt8OrZero('0xc0fe');`。
入力値が [`UInt8`](/ja/reference/data-types/int-uint) の範囲内で表現できない場合、結果はオーバーフローまたはアンダーフローします。
これはエラーとは見なされません。
関連項目:
* [`toUInt8`](#toUInt8)。
* [`toUInt8OrNull`](#toUInt8OrNull)。
* [`toUInt8OrDefault`](#toUInt8OrDefault)。
**構文**
```sql theme={null}
toUInt8OrZero(x)
```
**引数**
* `x` — 数値の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
`UInt8` 型の値を返します。変換に失敗した場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUInt8OrZero('-8'),
toUInt8OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt8OrZero('-8'): 0
toUInt8OrZero('abc'): 0
```
## toUUID
導入バージョン: v1.1.0
String 型の値を UUID 値に変換します。
**構文**
```sql theme={null}
toUUID(string)
```
**引数**
* `string` — UUID の文字列表現。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
**戻り値**
UUID の文字列表現から UUID を返します。[`UUID`](/ja/reference/data-types/uuid)
**例**
**使用例**
```sql title=Query theme={null}
SELECT toUUID('61f0c404-5cb3-11e7-907b-a6006ad3dba0') AS uuid
```
```response title=Response theme={null}
┌─────────────────────────────────uuid─┐
│ 61f0c404-5cb3-11e7-907b-a6006ad3dba0 │
└──────────────────────────────────────┘
```
## toUUIDOrZero
導入バージョン: v20.12.0
入力値を [UUID](/ja/reference/data-types/uuid) 型の値に変換しますが、エラーが発生した場合はゼロ UUID を返します。
[`toUUID`](/ja/reference/functions/regular-functions/type-conversion-functions#toUUID) と似ていますが、変換エラー時に例外をスローする代わりに、ゼロ UUID (`00000000-0000-0000-0000-000000000000`) を返します。
サポートされる引数:
* 標準形式 (8-4-4-4-12 桁の16進数) の UUID の文字列表現。
* ハイフンなし (32 桁の16進数) の UUID の文字列表現。
サポートされない引数 (ゼロ UUID を返します) :
* 無効な文字列形式。
* 文字列以外の型。
**構文**
```sql theme={null}
toUUIDOrZero(x)
```
**引数**
* `x` — UUID の文字列表現。[`String`](/ja/reference/data-types/string)
**戻り値**
成功した場合は UUID 値を返し、失敗した場合はゼロ UUID (`00000000-0000-0000-0000-000000000000`) を返します。[`UUID`](/ja/reference/data-types/uuid)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
toUUIDOrZero('550e8400-e29b-41d4-a716-446655440000') AS valid_uuid,
toUUIDOrZero('invalid-uuid') AS invalid_uuid
```
```response title=Response theme={null}
┌─valid_uuid───────────────────────────┬─invalid_uuid─────────────────────────┐
│ 550e8400-e29b-41d4-a716-446655440000 │ 00000000-0000-0000-0000-000000000000 │
└──────────────────────────────────────┴──────────────────────────────────────┘
```
## toUnixTimestamp64Micro
導入バージョン: v20.5.0
[`DateTime64`](/ja/reference/data-types/datetime64) を、固定のマイクロ秒精度を持つ [`Int64`](/ja/reference/data-types/int-uint) 値に変換します。
入力値は、その精度に応じて適切にスケールアップまたはスケールダウンされます。
出力値は入力値のタイムゾーンではなく、UTC を基準とします。
**構文**
```sql theme={null}
toUnixTimestamp64Micro(value)
```
**引数**
* `value` — 任意の精度を持つ DateTime64 の値。[`DateTime64`](/ja/reference/data-types/datetime64)
**戻り値**
マイクロ秒単位の Unixタイムスタンプを返します。[`Int64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011123', 6, 'UTC') AS dt64
SELECT toUnixTimestamp64Micro(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Micro(dt64)─┐
│ 1739489491011123 │
└────────────────────────────────┘
```
## toUnixTimestamp64Milli
導入バージョン: v20.5.0
[`DateTime64`](/ja/reference/data-types/datetime64) を、固定のミリ秒精度を持つ [`Int64`](/ja/reference/data-types/int-uint) 値に変換します。
入力値は、その精度に応じて適切にスケールアップまたはスケールダウンされます。
出力値は入力値のタイムゾーンではなく、UTC を基準とします。
**構文**
```sql theme={null}
toUnixTimestamp64Milli(value)
```
**引数**
* `value` — 任意の精度を持つ DateTime64 値。[`DateTime64`](/ja/reference/data-types/datetime64)
**戻り値**
ミリ秒単位の Unix タイムスタンプを返します。[`Int64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011', 3, 'UTC') AS dt64
SELECT toUnixTimestamp64Milli(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Milli(dt64)─┐
│ 1739489491011 │
└──────────────────────────────┘
```
## toUnixTimestamp64Nano
導入バージョン: v20.5.0
[`DateTime64`](/ja/reference/data-types/datetime64) を、固定のナノ秒精度を持つ [`Int64`](/ja/reference/functions/regular-functions/type-conversion-functions#toInt64) 値に変換します。
入力値は、その精度に応じて適切に拡大または縮小されます。
出力値は、入力値のタイムゾーンではなく、UTC を基準にしています。
**構文**
```sql theme={null}
toUnixTimestamp64Nano(value)
```
**引数**
* `value` — 任意の精度の DateTime64 値。[`DateTime64`](/ja/reference/data-types/datetime64)
**戻り値**
ナノ秒単位の Unix タイムスタンプを返します。[`Int64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011123456', 9, 'UTC') AS dt64
SELECT toUnixTimestamp64Nano(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Nano(dt64)────┐
│ 1739489491011123456 │
└────────────────────────────────┘
```
## toUnixTimestamp64Second
導入バージョン: v24.12.0
[`DateTime64`](/ja/reference/data-types/datetime64) を、秒単位の固定精度を持つ [`Int64`](/ja/reference/data-types/int-uint) 値に変換します。
入力値は、その精度に応じて適切にスケールアップまたはスケールダウンされます。
出力値は、入力値のタイムゾーンではなく、UTC を基準とします。
**構文**
```sql theme={null}
toUnixTimestamp64Second(value)
```
**引数**
* `value` — 任意の精度を持つ DateTime64 型の値。[`DateTime64`](/ja/reference/data-types/datetime64)
**戻り値**
秒単位の Unixタイムスタンプを返します。[`Int64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011', 3, 'UTC') AS dt64
SELECT toUnixTimestamp64Second(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Second(dt64)─┐
│ 1739489491 │
└───────────────────────────────┘
```