类型转换函数
数据转换常见问题
ClickHouse 通常使用与 C++ 程序相同的行为。
to<type> 函数和cast在某些情况下表现不同，例如在LowCardinality的情况下：cast会移除LowCardinality特性，to<type> 函数不会。 Nullable也是如此，此行为与 SQL 标准不兼容，可以使用cast_keep_nullable设置进行更改。
如果将数据类型的值转换为较小的数据类型（例如从Int64到Int32）或在不兼容的数据类型之间转换（例如从String到Int），请注意可能会丢失数据。 请务必仔细检查结果是否符合预期。
示例
SELECT
toTypeName(toLowCardinality('') AS val) AS source_type,
toTypeName(toString(val)) AS to_type_result_type,
toTypeName(CAST(val, 'String')) AS cast_result_type
┌─source_type────────────┬─to_type_result_type────┬─cast_result_type─┐
│ LowCardinality(String) │ LowCardinality(String) │ String │
└────────────────────────┴────────────────────────┴──────────────────┘
SELECT
toTypeName(toNullable('') AS val) AS source_type,
toTypeName(toString(val)) AS to_type_result_type,
toTypeName(CAST(val, 'String')) AS cast_result_type
┌─source_type──────┬─to_type_result_type─┬─cast_result_type─┐
│ Nullable(String) │ Nullable(String) │ String │
└──────────────────┴─────────────────────┴──────────────────┘
SELECT
toTypeName(toNullable('') AS val) AS source_type,
toTypeName(toString(val)) AS to_type_result_type,
toTypeName(CAST(val, 'String')) AS cast_result_type
SETTINGS cast_keep_nullable = 1
┌─source_type──────┬─to_type_result_type─┬─cast_result_type─┐
│ Nullable(String) │ Nullable(String) │ Nullable(String) │
└──────────────────┴─────────────────────┴──────────────────┘
toBool
将输入值转换为Bool类型的值。如果发生错误，则抛出异常。
语法
toBool(expr)
参数
expr— 返回数字或字符串的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值。
- Float32/64 类型的数值。
- 字符串
true或false（不区分大小写）。
返回值
- 根据参数的评估结果返回
true或false。 Bool。
示例
查询
SELECT
toBool(toUInt8(1)),
toBool(toInt8(-1)),
toBool(toFloat32(1.01)),
toBool('true'),
toBool('false'),
toBool('FALSE')
FORMAT Vertical
结果
toBool(toUInt8(1)): true
toBool(toInt8(-1)): true
toBool(toFloat32(1.01)): true
toBool('true'): true
toBool('false'): false
toBool('FALSE'): false
toInt8
将输入值转换为Int8类型的值。如果发生错误，则抛出异常。
语法
toInt8(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt8('0xc0fe');。
如果输入值无法在Int8的范围内表示，则会发生结果溢出或下溢。这不被视为错误。
例如：SELECT toInt8(128) == -128;。
返回值
- 8 位整数值。 Int8。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt8(-8),
toInt8(-8.8),
toInt8('-8')
FORMAT Vertical;
结果
Row 1:
──────
toInt8(-8): -8
toInt8(-8.8): -8
toInt8('-8'): -8
另请参阅
toInt8OrZero
与toInt8类似，此函数将输入值转换为Int8类型的值，但在发生错误时返回0。
语法
toInt8OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- 普通 Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt8OrZero('0xc0fe');。
如果输入值无法在Int8的范围内表示，则会发生结果溢出或下溢。这不被视为错误。
返回值
- 如果成功则为 8 位整数值，否则为
0。 Int8。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt8OrZero('-8'),
toInt8OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt8OrZero('-8'): -8
toInt8OrZero('abc'): 0
另请参阅
toInt8OrNull
与toInt8类似，此函数将输入值转换为Int8类型的值，但在发生错误时返回NULL。
语法
toInt8OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt8OrNull('0xc0fe');。
如果输入值无法在Int8的范围内表示，则会发生结果溢出或下溢。这不被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt8OrNull('-8'),
toInt8OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt8OrNull('-8'): -8
toInt8OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toInt8OrDefault
与toInt8类似，此函数将输入值转换为Int8类型的值，但在发生错误时返回默认值。如果未传递default值，则在发生错误时返回0。
语法
toInt8OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt8OrDefault('0xc0fe', CAST('-1', 'Int8'));。
如果输入值无法在Int8的范围内表示，则会发生结果溢出或下溢。这不被视为错误。
返回值
- 如果成功则为 8 位整数值，否则返回传递的默认值或
0（如果未传递）。 Int8。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toInt8OrDefault('-8', CAST('-1', 'Int8')),
toInt8OrDefault('abc', CAST('-1', 'Int8'))
FORMAT Vertical;
结果
Row 1:
──────
toInt8OrDefault('-8', CAST('-1', 'Int8')): -8
toInt8OrDefault('abc', CAST('-1', 'Int8')): -1
另请参阅
toInt16
将输入值转换为Int16类型的值。如果发生错误，则抛出异常。
语法
toInt16(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt16('0xc0fe');。
如果输入值无法在Int16的范围内表示，则会发生结果溢出或下溢。这不被视为错误。
例如：SELECT toInt16(32768) == -32768;。
返回值
- 16 位整数值。 Int16。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt16(-16),
toInt16(-16.16),
toInt16('-16')
FORMAT Vertical;
结果
Row 1:
──────
toInt16(-16): -16
toInt16(-16.16): -16
toInt16('-16'): -16
另请参阅
toInt16OrZero
与toInt16类似，此函数将输入值转换为Int16类型的值，但在发生错误时返回0。
语法
toInt16OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt16OrZero('0xc0fe');。
如果输入值无法在Int16的范围内表示，则会发生结果溢出或下溢。这不被视为错误。
返回值
- 如果成功则为 16 位整数值，否则为
0。 Int16。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt16OrZero('-16'),
toInt16OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt16OrZero('-16'): -16
toInt16OrZero('abc'): 0
另请参阅
toInt16OrNull
与toInt16类似，此函数将输入值转换为Int16类型的值，但在发生错误时返回NULL。
语法
toInt16OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt16OrNull('0xc0fe');。
如果输入值无法在Int16的范围内表示，则会发生结果溢出或下溢。这不被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt16OrNull('-16'),
toInt16OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt16OrNull('-16'): -16
toInt16OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toInt16OrDefault
与toInt16类似，此函数将输入值转换为Int16类型的值，但在发生错误时返回默认值。如果未传递default值，则在发生错误时返回0。
语法
toInt16OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt16OrDefault('0xc0fe', CAST('-1', 'Int16'));。
如果输入值无法在Int16的范围内表示，则会发生结果溢出或下溢。这不被视为错误。
返回值
- 如果成功则为 16 位整数值，否则返回传递的默认值或
0（如果未传递）。 Int16。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toInt16OrDefault('-16', CAST('-1', 'Int16')),
toInt16OrDefault('abc', CAST('-1', 'Int16'))
FORMAT Vertical;
结果
Row 1:
──────
toInt16OrDefault('-16', CAST('-1', 'Int16')): -16
toInt16OrDefault('abc', CAST('-1', 'Int16')): -1
另请参阅
toInt32
将输入值转换为Int32类型的值。如果发生错误，则抛出异常。
语法
toInt32(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt32('0xc0fe');。
如果输入值无法在 Int32 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
例如：SELECT toInt32(2147483648) == -2147483648;
返回值
- 32 位整数。 Int32。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt32(-32),
toInt32(-32.32),
toInt32('-32')
FORMAT Vertical;
结果
Row 1:
──────
toInt32(-32): -32
toInt32(-32.32): -32
toInt32('-32'): -32
另请参阅
toInt32OrZero
与 toInt32 类似，此函数将输入值转换为 Int32 类型的值，但在发生错误时返回 0。
语法
toInt32OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt32OrZero('0xc0fe');。
如果输入值无法在 Int32 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功则为 32 位整数，否则为
0。 Int32
该函数使用 向零舍入，这意味着它会截断数字的小数部分。
示例
查询
SELECT
toInt32OrZero('-32'),
toInt32OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt32OrZero('-32'): -32
toInt32OrZero('abc'): 0
另请参阅
toInt32OrNull
与 toInt32 类似，此函数将输入值转换为 Int32 类型的值，但在发生错误时返回 NULL。
语法
toInt32OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt32OrNull('0xc0fe');。
如果输入值无法在 Int32 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt32OrNull('-32'),
toInt32OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt32OrNull('-32'): -32
toInt32OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toInt32OrDefault
与 toInt32 类似，此函数将输入值转换为 Int32 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toInt32OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt32OrDefault('0xc0fe', CAST('-1', 'Int32'));。
如果输入值无法在 Int32 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功则为 32 位整数，否则返回传递的默认值或
0（如果未传递）。 Int32。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toInt32OrDefault('-32', CAST('-1', 'Int32')),
toInt32OrDefault('abc', CAST('-1', 'Int32'))
FORMAT Vertical;
结果
Row 1:
──────
toInt32OrDefault('-32', CAST('-1', 'Int32')): -32
toInt32OrDefault('abc', CAST('-1', 'Int32')): -1
另请参阅
toInt64
将输入值转换为 Int64 类型的值。如果发生错误，则抛出异常。
语法
toInt64(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的类型
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt64('0xc0fe');。
如果输入值无法在 Int64 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
例如：SELECT toInt64(9223372036854775808) == -9223372036854775808;
返回值
- 64 位整数。 Int64。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt64(-64),
toInt64(-64.64),
toInt64('-64')
FORMAT Vertical;
结果
Row 1:
──────
toInt64(-64): -64
toInt64(-64.64): -64
toInt64('-64'): -64
另请参阅
toInt64OrZero
与 toInt64 类似，此函数将输入值转换为 Int64 类型的值，但在发生错误时返回 0。
语法
toInt64OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt64OrZero('0xc0fe');。
如果输入值无法在 Int64 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功则为 64 位整数，否则为
0。 Int64。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt64OrZero('-64'),
toInt64OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt64OrZero('-64'): -64
toInt64OrZero('abc'): 0
另请参阅
toInt64OrNull
与 toInt64 类似，此函数将输入值转换为 Int64 类型的值，但在发生错误时返回 NULL。
语法
toInt64OrNull(x)
参数
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt64OrNull('0xc0fe');。
如果输入值无法在 Int64 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt64OrNull('-64'),
toInt64OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt64OrNull('-64'): -64
toInt64OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toInt64OrDefault
与 toInt64 类似，此函数将输入值转换为 Int64 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toInt64OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt64OrDefault('0xc0fe', CAST('-1', 'Int64'));。
如果输入值无法在 Int64 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功则为 64 位整数，否则返回传递的默认值或
0（如果未传递）。 Int64。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toInt64OrDefault('-64', CAST('-1', 'Int64')),
toInt64OrDefault('abc', CAST('-1', 'Int64'))
FORMAT Vertical;
结果
Row 1:
──────
toInt64OrDefault('-64', CAST('-1', 'Int64')): -64
toInt64OrDefault('abc', CAST('-1', 'Int64')): -1
另请参阅
toInt128
将输入值转换为 Int128 类型的值。如果发生错误，则抛出异常。
语法
toInt128(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt128('0xc0fe');。
如果输入值无法在 Int128 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 128 位整数。 Int128。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt128(-128),
toInt128(-128.8),
toInt128('-128')
FORMAT Vertical;
结果
Row 1:
──────
toInt128(-128): -128
toInt128(-128.8): -128
toInt128('-128'): -128
另请参阅
toInt128OrZero
与 toInt128 类似，此函数将输入值转换为 Int128 类型的值，但在发生错误时返回 0。
语法
toInt128OrZero(expr)
参数
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt128OrZero('0xc0fe');。
如果输入值无法在 Int128 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功则为 128 位整数，否则为
0。 Int128。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt128OrZero('-128'),
toInt128OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt128OrZero('-128'): -128
toInt128OrZero('abc'): 0
另请参阅
toInt128OrNull
与 toInt128 类似，此函数将输入值转换为 Int128 类型的值，但在发生错误时返回 NULL。
语法
toInt128OrNull(x)
参数
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt128OrNull('0xc0fe');。
如果输入值无法在 Int128 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt128OrNull('-128'),
toInt128OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt128OrNull('-128'): -128
toInt128OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toInt128OrDefault
与 toInt128 类似，此函数将输入值转换为 Int128 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toInt128OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256。
- Float32/64。
- (U)Int8/16/32/128/256 类型的字符串表示形式。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt128OrDefault('0xc0fe', CAST('-1', 'Int128'));。
如果输入值无法在 Int128 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功则为 128 位整数，否则返回传递的默认值或
0（如果未传递）。 Int128。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toInt128OrDefault('-128', CAST('-1', 'Int128')),
toInt128OrDefault('abc', CAST('-1', 'Int128'))
FORMAT Vertical;
结果
Row 1:
──────
toInt128OrDefault('-128', CAST('-1', 'Int128')): -128
toInt128OrDefault('abc', CAST('-1', 'Int128')): -1
另请参阅
toInt256
将输入值转换为 Int256 类型的值。如果发生错误，则抛出异常。
语法
toInt256(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt256('0xc0fe');。
如果输入值无法在 Int256 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 256 位整数。 Int256。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt256(-256),
toInt256(-256.256),
toInt256('-256')
FORMAT Vertical;
结果
Row 1:
──────
toInt256(-256): -256
toInt256(-256.256): -256
toInt256('-256'): -256
另请参阅
toInt256OrZero
与 toInt256 类似，此函数将输入值转换为 Int256 类型的值，但在发生错误时返回 0。
语法
toInt256OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt256OrZero('0xc0fe');。
如果输入值无法在 Int256 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功则为 256 位整数，否则为
0。 Int256。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt256OrZero('-256'),
toInt256OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt256OrZero('-256'): -256
toInt256OrZero('abc'): 0
另请参阅
toInt256OrNull
与 toInt256 类似，此函数将输入值转换为 Int256 类型的值，但在发生错误时返回 NULL。
语法
toInt256OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt256OrNull('0xc0fe');。
如果输入值无法在 Int256 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toInt256OrNull('-256'),
toInt256OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toInt256OrNull('-256'): -256
toInt256OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toInt256OrDefault
与 toInt256 类似，此函数将输入值转换为 Int256 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toInt256OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf - 二进制和十六进制值的字符串表示形式，例如
SELECT toInt256OrDefault('0xc0fe', CAST('-1', 'Int256'));。
如果输入值无法在 Int256 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功则为 256 位整数，否则返回传递的默认值或
0（如果未传递）。 Int256。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toInt256OrDefault('-256', CAST('-1', 'Int256')),
toInt256OrDefault('abc', CAST('-1', 'Int256'))
FORMAT Vertical;
结果
Row 1:
──────
toInt256OrDefault('-256', CAST('-1', 'Int256')): -256
toInt256OrDefault('abc', CAST('-1', 'Int256')): -1
另请参阅
toUInt8
将输入值转换为 UInt8 类型的值。如果发生错误，则抛出异常。
语法
toUInt8(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt8('0xc0fe');。
如果输入值无法在 UInt8 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
例如：SELECT toUInt8(256) == 0;。
返回值
- 8 位无符号整数。 UInt8。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt8(8),
toUInt8(8.8),
toUInt8('8')
FORMAT Vertical;
结果
Row 1:
──────
toUInt8(8): 8
toUInt8(8.8): 8
toUInt8('8'): 8
另请参阅
toUInt8OrZero
与 toUInt8 类似，此函数将输入值转换为 UInt8 类型的值，但在发生错误时返回 0。
语法
toUInt8OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- 普通 Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt8OrZero('0xc0fe');。
如果输入值无法在 UInt8 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功则为 8 位无符号整数，否则为
0。 UInt8。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt8OrZero('-8'),
toUInt8OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt8OrZero('-8'): 0
toUInt8OrZero('abc'): 0
另请参阅
toUInt8OrNull
类似于 toUInt8，此函数将输入值转换为 UInt8 类型的值，但在发生错误时返回 NULL。
语法
toUInt8OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt8OrNull('0xc0fe');。
如果输入值无法在 UInt8 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt8OrNull('8'),
toUInt8OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt8OrNull('8'): 8
toUInt8OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toUInt8OrDefault
类似于 toUInt8，此函数将输入值转换为 UInt8 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toUInt8OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt8OrDefault('0xc0fe', CAST('0', 'UInt8'));。
如果输入值无法在 UInt8 的范围内表示，则结果会溢出或下溢。这不会被视为错误。
返回值
- 如果成功，则为 8 位无符号整数；否则，如果传递了默认值，则返回该默认值；否则返回
0。 UInt8。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toUInt8OrDefault('8', CAST('0', 'UInt8')),
toUInt8OrDefault('abc', CAST('0', 'UInt8'))
FORMAT Vertical;
结果
Row 1:
──────
toUInt8OrDefault('8', CAST('0', 'UInt8')): 8
toUInt8OrDefault('abc', CAST('0', 'UInt8')): 0
另请参阅
toUInt16
将输入值转换为 UInt16 类型的值。如果发生错误，则抛出异常。
语法
toUInt16(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt16('0xc0fe');。
如果输入值不能在 UInt16 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
例如：SELECT toUInt16(65536) == 0;。
返回值
- 16 位无符号整数。 UInt16。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt16(16),
toUInt16(16.16),
toUInt16('16')
FORMAT Vertical;
结果
Row 1:
──────
toUInt16(16): 16
toUInt16(16.16): 16
toUInt16('16'): 16
另请参阅
toUInt16OrZero
类似于 toUInt16，此函数将输入值转换为 UInt16 类型的值，但在发生错误时返回 0。
语法
toUInt16OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt16OrZero('0xc0fe');。
如果输入值不能在 UInt16 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
- 如果成功，则为 16 位无符号整数；否则为
0。 UInt16。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt16OrZero('16'),
toUInt16OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt16OrZero('16'): 16
toUInt16OrZero('abc'): 0
另请参阅
toUInt16OrNull
类似于 toUInt16，此函数将输入值转换为 UInt16 类型的值，但在发生错误时返回 NULL。
语法
toUInt16OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt16OrNull('0xc0fe');。
如果输入值不能在 UInt16 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt16OrNull('16'),
toUInt16OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt16OrNull('16'): 16
toUInt16OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toUInt16OrDefault
类似于 toUInt16，此函数将输入值转换为 UInt16 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toUInt16OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt16OrDefault('0xc0fe', CAST('0', 'UInt16'));。
如果输入值不能在 UInt16 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
- 如果成功，则为 16 位无符号整数；否则，如果传递了默认值，则返回该默认值；否则返回
0。 UInt16。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toUInt16OrDefault('16', CAST('0', 'UInt16')),
toUInt16OrDefault('abc', CAST('0', 'UInt16'))
FORMAT Vertical;
结果
Row 1:
──────
toUInt16OrDefault('16', CAST('0', 'UInt16')): 16
toUInt16OrDefault('abc', CAST('0', 'UInt16')): 0
另请参阅
toUInt32
将输入值转换为 UInt32 类型的值。如果发生错误，则抛出异常。
语法
toUInt32(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt32('0xc0fe');。
如果输入值不能在 UInt32 的范围内表示，则结果会溢出或下溢。这不被视为错误。
例如：SELECT toUInt32(4294967296) == 0;
返回值
- 32 位无符号整数。 UInt32。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt32(32),
toUInt32(32.32),
toUInt32('32')
FORMAT Vertical;
结果
Row 1:
──────
toUInt32(32): 32
toUInt32(32.32): 32
toUInt32('32'): 32
另请参阅
toUInt32OrZero
类似于 toUInt32，此函数将输入值转换为 UInt32 类型的值，但在发生错误时返回 0。
语法
toUInt32OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt32OrZero('0xc0fe');。
如果输入值不能在 UInt32 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
- 如果成功，则为 32 位无符号整数；否则为
0。 UInt32
该函数使用 向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt32OrZero('32'),
toUInt32OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt32OrZero('32'): 32
toUInt32OrZero('abc'): 0
另请参阅
toUInt32OrNull
类似于 toUInt32，此函数将输入值转换为 UInt32 类型的值，但在发生错误时返回 NULL。
语法
toUInt32OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt32OrNull('0xc0fe');。
如果输入值不能在 UInt32 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
该函数使用 向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt32OrNull('32'),
toUInt32OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt32OrNull('32'): 32
toUInt32OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toUInt32OrDefault
类似于 toUInt32，此函数将输入值转换为 UInt32 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toUInt32OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt32OrDefault('0xc0fe', CAST('0', 'UInt32'));。
如果输入值不能在 UInt32 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
- 如果成功，则为 32 位无符号整数；否则，如果传递了默认值，则返回该默认值；否则返回
0。 UInt32。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toUInt32OrDefault('32', CAST('0', 'UInt32')),
toUInt32OrDefault('abc', CAST('0', 'UInt32'))
FORMAT Vertical;
结果
Row 1:
──────
toUInt32OrDefault('32', CAST('0', 'UInt32')): 32
toUInt32OrDefault('abc', CAST('0', 'UInt32')): 0
另请参阅
toUInt64
将输入值转换为 UInt64 类型的值。如果发生错误，则抛出异常。
语法
toUInt64(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的类型
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt64('0xc0fe');。
如果输入值不能在 UInt64 的范围内表示，则结果会溢出或下溢。这不被视为错误。
例如：SELECT toUInt64(18446744073709551616) == 0;
返回值
- 64 位无符号整数。 UInt64。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt64(64),
toUInt64(64.64),
toUInt64('64')
FORMAT Vertical;
结果
Row 1:
──────
toUInt64(64): 64
toUInt64(64.64): 64
toUInt64('64'): 64
另请参阅
toUInt64OrZero
类似于 toUInt64，此函数将输入值转换为 UInt64 类型的值，但在发生错误时返回 0。
语法
toUInt64OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt64OrZero('0xc0fe');。
如果输入值不能在 UInt64 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
- 如果成功，则为 64 位无符号整数；否则为
0。 UInt64。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt64OrZero('64'),
toUInt64OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt64OrZero('64'): 64
toUInt64OrZero('abc'): 0
另请参阅
toUInt64OrNull
类似于 toUInt64，此函数将输入值转换为 UInt64 类型的值，但在发生错误时返回 NULL。
语法
toUInt64OrNull(x)
参数
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt64OrNull('0xc0fe');。
如果输入值不能在 UInt64 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt64OrNull('64'),
toUInt64OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt64OrNull('64'): 64
toUInt64OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toUInt64OrDefault
类似于 toUInt64，此函数将输入值转换为 UInt64 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toUInt64OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt64OrDefault('0xc0fe', CAST('0', 'UInt64'));。
如果输入值不能在 UInt64 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
- 如果成功，则为 64 位无符号整数；否则，如果传递了默认值，则返回该默认值；否则返回
0。 UInt64。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toUInt64OrDefault('64', CAST('0', 'UInt64')),
toUInt64OrDefault('abc', CAST('0', 'UInt64'))
FORMAT Vertical;
结果
Row 1:
──────
toUInt64OrDefault('64', CAST('0', 'UInt64')): 64
toUInt64OrDefault('abc', CAST('0', 'UInt64')): 0
另请参阅
toUInt128
将输入值转换为 UInt128 类型的值。如果发生错误，则抛出异常。
语法
toUInt128(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt128('0xc0fe');。
如果输入值不能在 UInt128 的范围内表示，则结果会溢出或下溢。这不被视为错误。
返回值
- 128 位无符号整数。 UInt128。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt128(128),
toUInt128(128.8),
toUInt128('128')
FORMAT Vertical;
结果
Row 1:
──────
toUInt128(128): 128
toUInt128(128.8): 128
toUInt128('128'): 128
另请参阅
toUInt128OrZero
类似于 toUInt128，此函数将输入值转换为 UInt128 类型的值，但在发生错误时返回 0。
语法
toUInt128OrZero(expr)
参数
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt128OrZero('0xc0fe');。
如果输入值不能在 UInt128 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
- 如果成功，则为 128 位无符号整数；否则为
0。 UInt128。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt128OrZero('128'),
toUInt128OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt128OrZero('128'): 128
toUInt128OrZero('abc'): 0
另请参阅
toUInt128OrNull
类似于 toUInt128，此函数将输入值转换为 UInt128 类型的值，但在发生错误时返回 NULL。
语法
toUInt128OrNull(x)
参数
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt128OrNull('0xc0fe');。
如果输入值不能在 UInt128 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt128OrNull('128'),
toUInt128OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt128OrNull('128'): 128
toUInt128OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toUInt128OrDefault
类似于 toUInt128，此函数将输入值转换为 UInt128 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toUInt128OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256。
- Float32/64。
- (U)Int8/16/32/128/256 类型的字符串表示形式。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt128OrDefault('0xc0fe', CAST('0', 'UInt128'));。
如果输入值不能在 UInt128 的范围内表示，则会发生结果的溢出或下溢。这不被视为错误。
返回值
- 如果成功，则返回 128 位无符号整数，否则返回传递的默认值，如果未传递则返回
0。 UInt128。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toUInt128OrDefault('128', CAST('0', 'UInt128')),
toUInt128OrDefault('abc', CAST('0', 'UInt128'))
FORMAT Vertical;
结果
Row 1:
──────
toUInt128OrDefault('128', CAST('0', 'UInt128')): 128
toUInt128OrDefault('abc', CAST('0', 'UInt128')): 0
另请参阅
toUInt256
将输入值转换为 UInt256 类型的值。如果发生错误，则抛出异常。
语法
toUInt256(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
不支持的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt256('0xc0fe');。
如果输入值不能在 UInt256 的范围内表示，则结果会溢出或下溢。这不被视为错误。
返回值
- 256 位无符号整数。 Int256。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt256(256),
toUInt256(256.256),
toUInt256('256')
FORMAT Vertical;
结果
Row 1:
──────
toUInt256(256): 256
toUInt256(256.256): 256
toUInt256('256'): 256
另请参阅
toUInt256OrZero
类似于 toUInt256，此函数将输入值转换为 UInt256 类型的值，但在发生错误时返回 0。
语法
toUInt256OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回0）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt256OrZero('0xc0fe');。
如果输入值不能在 UInt256 的范围内表示，则结果会溢出或下溢。这不被视为错误。
返回值
- 如果成功，则返回 256 位无符号整数，否则返回
0。 UInt256。
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt256OrZero('256'),
toUInt256OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt256OrZero('256'): 256
toUInt256OrZero('abc'): 0
另请参阅
toUInt256OrNull
类似于 toUInt256，此函数将输入值转换为 UInt256 类型的值，但在发生错误时返回 NULL。
语法
toUInt256OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256 类型的字符串表示形式。
不支持的参数（返回\N）
- Float32/64 值的字符串表示形式，包括
NaN和Inf。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt256OrNull('0xc0fe');。
如果输入值不能在 UInt256 的范围内表示，则结果会溢出或下溢。这不被视为错误。
返回值
该函数使用向零舍入，这意味着它会截断数字的小数位。
示例
查询
SELECT
toUInt256OrNull('256'),
toUInt256OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toUInt256OrNull('256'): 256
toUInt256OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toUInt256OrDefault
类似于 toUInt256，此函数将输入值转换为 UInt256 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toUInt256OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的数值。
返回默认值的参数
- Float32/64 值的字符串表示形式，包括
NaN和Inf - 二进制和十六进制值的字符串表示形式，例如
SELECT toUInt256OrDefault('0xc0fe', CAST('0', 'UInt256'));
如果输入值不能在 UInt256 的范围内表示，则结果会溢出或下溢。这不被视为错误。
返回值
- 如果成功，则返回 256 位无符号整数，否则返回传递的默认值，如果未传递则返回
0。 UInt256。
- 该函数使用向零舍入，这意味着它会截断数字的小数位。
- 默认值的类型应与转换类型相同。
示例
查询
SELECT
toUInt256OrDefault('-256', CAST('0', 'UInt256')),
toUInt256OrDefault('abc', CAST('0', 'UInt256'))
FORMAT Vertical;
结果
Row 1:
──────
toUInt256OrDefault('-256', CAST('0', 'UInt256')): 0
toUInt256OrDefault('abc', CAST('0', 'UInt256')): 0
另请参阅
toFloat32
将输入值转换为 Float32 类型的值。如果发生错误，则抛出异常。
语法
toFloat32(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值。
- (U)Int8/16/32/128/256 类型的字符串表示形式。
- Float32/64 类型的值，包括
NaN和Inf。 - Float32/64 的字符串表示形式，包括
NaN和Inf（不区分大小写）。
不支持的参数
- 二进制和十六进制值的字符串表示形式，例如
SELECT toFloat32('0xc0fe');。
返回值
- 32 位浮点数。 Float32。
示例
查询
SELECT
toFloat32(42.7),
toFloat32('42.7'),
toFloat32('NaN')
FORMAT Vertical;
结果
Row 1:
──────
toFloat32(42.7): 42.7
toFloat32('42.7'): 42.7
toFloat32('NaN'): nan
另请参阅
toFloat32OrZero
类似于 toFloat32，此函数将输入值转换为 Float32 类型的值，但在发生错误时返回 0。
语法
toFloat32OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256、Float32/64 的字符串表示形式。
不支持的参数（返回0）
- 二进制和十六进制值的字符串表示形式，例如
SELECT toFloat32OrZero('0xc0fe');。
返回值
- 如果成功，则返回 32 位浮点值，否则返回
0。 Float32。
示例
查询
SELECT
toFloat32OrZero('42.7'),
toFloat32OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toFloat32OrZero('42.7'): 42.7
toFloat32OrZero('abc'): 0
另请参阅
toFloat32OrNull
类似于 toFloat32，此函数将输入值转换为 Float32 类型的值，但在发生错误时返回 NULL。
语法
toFloat32OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256、Float32/64 的字符串表示形式。
不支持的参数（返回\N）
- 二进制和十六进制值的字符串表示形式，例如
SELECT toFloat32OrNull('0xc0fe');。
返回值
- 如果成功，则返回 32 位浮点值，否则返回
\N。 Float32。
示例
查询
SELECT
toFloat32OrNull('42.7'),
toFloat32OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toFloat32OrNull('42.7'): 42.7
toFloat32OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toFloat32OrDefault
类似于 toFloat32，此函数将输入值转换为 Float32 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toFloat32OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值。
- (U)Int8/16/32/128/256 类型的字符串表示形式。
- Float32/64 类型的值，包括
NaN和Inf。 - Float32/64 的字符串表示形式，包括
NaN和Inf（不区分大小写）。
返回默认值的参数
- 二进制和十六进制值的字符串表示形式，例如
SELECT toFloat32OrDefault('0xc0fe', CAST('0', 'Float32'));
返回值
- 如果成功，则返回 32 位浮点值，否则返回传递的默认值，如果未传递则返回
0。 Float32。
示例
查询
SELECT
toFloat32OrDefault('8', CAST('0', 'Float32')),
toFloat32OrDefault('abc', CAST('0', 'Float32'))
FORMAT Vertical;
结果
Row 1:
──────
toFloat32OrDefault('8', CAST('0', 'Float32')): 8
toFloat32OrDefault('abc', CAST('0', 'Float32')): 0
另请参阅
toFloat64
将输入值转换为 Float64 类型的值。如果发生错误，则抛出异常。
语法
toFloat64(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。 表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值。
- (U)Int8/16/32/128/256 类型的字符串表示形式。
- Float32/64 类型的值，包括
NaN和Inf。 - Float32/64 类型的字符串表示形式，包括
NaN和Inf（不区分大小写）。
不支持的参数
- 二进制和十六进制值的字符串表示形式，例如
SELECT toFloat64('0xc0fe');。
返回值
- 64 位浮点数。 Float64。
示例
查询
SELECT
toFloat64(42.7),
toFloat64('42.7'),
toFloat64('NaN')
FORMAT Vertical;
结果
Row 1:
──────
toFloat64(42.7): 42.7
toFloat64('42.7'): 42.7
toFloat64('NaN'): nan
另请参阅
toFloat64OrZero
类似于 toFloat64，此函数将输入值转换为 Float64 类型的值，但在发生错误时返回 0。
语法
toFloat64OrZero(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256、Float32/64 的字符串表示形式。
不支持的参数（返回0）
- 二进制和十六进制值的字符串表示形式，例如
SELECT toFloat64OrZero('0xc0fe');。
返回值
- 如果成功，则返回 64 位浮点值，否则返回
0。 Float64。
示例
查询
SELECT
toFloat64OrZero('42.7'),
toFloat64OrZero('abc')
FORMAT Vertical;
结果
Row 1:
──────
toFloat64OrZero('42.7'): 42.7
toFloat64OrZero('abc'): 0
另请参阅
toFloat64OrNull
类似于 toFloat64，此函数将输入值转换为 Float64 类型的值，但在发生错误时返回 NULL。
语法
toFloat64OrNull(x)
参数
x— 数字的字符串表示形式。 String。
支持的参数
- (U)Int8/16/32/128/256、Float32/64 的字符串表示形式。
不支持的参数（返回\N）
- 二进制和十六进制值的字符串表示形式，例如
SELECT toFloat64OrNull('0xc0fe');。
返回值
- 如果成功，则返回 64 位浮点值，否则返回
\N。 Float64。
示例
查询
SELECT
toFloat64OrNull('42.7'),
toFloat64OrNull('abc')
FORMAT Vertical;
结果
Row 1:
──────
toFloat64OrNull('42.7'): 42.7
toFloat64OrNull('abc'): ᴺᵁᴸᴸ
另请参阅
toFloat64OrDefault
类似于 toFloat64，此函数将输入值转换为 Float64 类型的值，但在发生错误时返回默认值。如果未传递 default 值，则在发生错误时返回 0。
语法
toFloat64OrDefault(expr[, default])
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值。
- (U)Int8/16/32/128/256 类型的字符串表示形式。
- Float32/64 类型的值，包括
NaN和Inf。 - Float32/64 的字符串表示形式，包括
NaN和Inf（不区分大小写）。
返回默认值的参数
- 二进制和十六进制值的字符串表示形式，例如
SELECT toFloat64OrDefault('0xc0fe', CAST('0', 'Float64'));
返回值
- 如果成功，则返回 64 位浮点值，否则返回传递的默认值，如果未传递则返回
0。 Float64。
示例
查询
SELECT
toFloat64OrDefault('8', CAST('0', 'Float64')),
toFloat64OrDefault('abc', CAST('0', 'Float64'))
FORMAT Vertical;
结果
Row 1:
──────
toFloat64OrDefault('8', CAST('0', 'Float64')): 8
toFloat64OrDefault('abc', CAST('0', 'Float64')): 0
另请参阅
toDate
将参数转换为 Date 数据类型。
如果参数是 DateTime 或 DateTime64，则将其截断并保留 DateTime 的日期部分。
SELECT
now() AS x,
toDate(x)
┌───────────────────x─┬─toDate(now())─┐
│ 2022-12-30 13:44:17 │ 2022-12-30 │
└─────────────────────┴───────────────┘
如果参数是 String，则将其解析为 Date 或 DateTime。如果将其解析为 DateTime，则使用日期部分。
SELECT
toDate('2022-12-30') AS x,
toTypeName(x)
┌──────────x─┬─toTypeName(toDate('2022-12-30'))─┐
│ 2022-12-30 │ Date │
└────────────┴──────────────────────────────────┘
1 row in set. Elapsed: 0.001 sec.
SELECT
toDate('2022-12-30 01:02:03') AS x,
toTypeName(x)
┌──────────x─┬─toTypeName(toDate('2022-12-30 01:02:03'))─┐
│ 2022-12-30 │ Date │
└────────────┴───────────────────────────────────────────┘
如果参数是数字并且看起来像 UNIX 时间戳（大于 65535），则将其解释为 DateTime，然后在当前时区将其截断为 Date。时区参数可以指定为函数的第二个参数。截断为 Date 取决于时区。
SELECT
now() AS current_time,
toUnixTimestamp(current_time) AS ts,
toDateTime(ts) AS time_Amsterdam,
toDateTime(ts, 'Pacific/Apia') AS time_Samoa,
toDate(time_Amsterdam) AS date_Amsterdam,
toDate(time_Samoa) AS date_Samoa,
toDate(ts) AS date_Amsterdam_2,
toDate(ts, 'Pacific/Apia') AS date_Samoa_2
Row 1:
──────
current_time: 2022-12-30 13:51:54
ts: 1672404714
time_Amsterdam: 2022-12-30 13:51:54
time_Samoa: 2022-12-31 01:51:54
date_Amsterdam: 2022-12-30
date_Samoa: 2022-12-31
date_Amsterdam_2: 2022-12-30
date_Samoa_2: 2022-12-31
上面的示例演示了相同的 UNIX 时间戳如何在不同的时区中解释为不同的日期。
如果参数是数字并且小于 65536，则将其解释为自 1970-01-01（第一个 UNIX 日）以来的天数，并转换为 Date。它对应于 Date 数据类型的内部数值表示。示例
SELECT toDate(12345)
┌─toDate(12345)─┐
│ 2003-10-20 │
└───────────────┘
此转换不依赖于时区。
如果参数不适合 Date 类型的范围，则会导致实现定义的行为，该行为可能会饱和到最大支持日期或溢出。
SELECT toDate(10000000000.)
┌─toDate(10000000000.)─┐
│ 2106-02-07 │
└──────────────────────┘
函数 toDate 也可以以其他形式编写。
SELECT
now() AS time,
toDate(time),
DATE(time),
CAST(time, 'Date')
┌────────────────time─┬─toDate(now())─┬─DATE(now())─┬─CAST(now(), 'Date')─┐
│ 2022-12-30 13:54:58 │ 2022-12-30 │ 2022-12-30 │ 2022-12-30 │
└─────────────────────┴───────────────┴─────────────┴─────────────────────┘
toDateOrZero
与 toDate 相同，但如果收到无效参数，则返回 Date 的下边界。仅支持 String 参数。
示例
查询
SELECT toDateOrZero('2022-12-30'), toDateOrZero('');
结果
┌─toDateOrZero('2022-12-30')─┬─toDateOrZero('')─┐
│ 2022-12-30 │ 1970-01-01 │
└────────────────────────────┴──────────────────┘
toDateOrNull
与 toDate 相同，但如果收到无效参数，则返回 NULL。仅支持 String 参数。
示例
查询
SELECT toDateOrNull('2022-12-30'), toDateOrNull('');
结果
┌─toDateOrNull('2022-12-30')─┬─toDateOrNull('')─┐
│ 2022-12-30 │ ᴺᵁᴸᴸ │
└────────────────────────────┴──────────────────┘
toDateOrDefault
类似于 toDate，但如果失败，则返回一个默认值，该值或者是第二个参数（如果指定），否则是 Date 的下边界。
语法
toDateOrDefault(expr [, default_value])
示例
查询
SELECT toDateOrDefault('2022-12-30'), toDateOrDefault('', '2023-01-01'::Date);
结果
┌─toDateOrDefault('2022-12-30')─┬─toDateOrDefault('', CAST('2023-01-01', 'Date'))─┐
│ 2022-12-30 │ 2023-01-01 │
└───────────────────────────────┴─────────────────────────────────────────────────┘
toDateTime
将输入值转换为 DateTime。
语法
toDateTime(expr[, time_zone ])
参数
如果 expr 是数字，则将其解释为自 Unix 纪元开始以来的秒数（作为 Unix 时间戳）。
如果 expr 是 String，则可以将其解释为 Unix 时间戳或日期/日期时间字符串表示形式。
因此，由于歧义，显式禁用短数字字符串表示形式（最多 4 位数字）的解析，例如字符串 '1999' 可以是年份（Date/DateTime 的不完整字符串表示形式）或 Unix 时间戳。允许使用更长的数字字符串。
返回值
- 日期时间。 DateTime
示例
查询
SELECT toDateTime('2022-12-30 13:44:17'), toDateTime(1685457500, 'UTC');
结果
┌─toDateTime('2022-12-30 13:44:17')─┬─toDateTime(1685457500, 'UTC')─┐
│ 2022-12-30 13:44:17 │ 2023-05-30 14:38:20 │
└───────────────────────────────────┴───────────────────────────────┘
toDateTimeOrZero
与 toDateTime 相同，但如果收到无效参数，则返回 DateTime 的下边界。仅支持 String 参数。
示例
查询
SELECT toDateTimeOrZero('2022-12-30 13:44:17'), toDateTimeOrZero('');
结果
┌─toDateTimeOrZero('2022-12-30 13:44:17')─┬─toDateTimeOrZero('')─┐
│ 2022-12-30 13:44:17 │ 1970-01-01 00:00:00 │
└─────────────────────────────────────────┴──────────────────────┘
toDateTimeOrNull
与 toDateTime 相同，但如果收到无效参数，则返回 NULL。仅支持 String 参数。
示例
查询
SELECT toDateTimeOrNull('2022-12-30 13:44:17'), toDateTimeOrNull('');
结果
┌─toDateTimeOrNull('2022-12-30 13:44:17')─┬─toDateTimeOrNull('')─┐
│ 2022-12-30 13:44:17 │ ᴺᵁᴸᴸ │
└─────────────────────────────────────────┴──────────────────────┘
toDateTimeOrDefault
类似于 toDateTime，但如果失败，则返回一个默认值，该默认值可以是第三个参数（如果指定），否则为 DateTime 的下边界。
语法
toDateTimeOrDefault(expr [, time_zone [, default_value]])
示例
查询
SELECT toDateTimeOrDefault('2022-12-30 13:44:17'), toDateTimeOrDefault('', 'UTC', '2023-01-01'::DateTime('UTC'));
结果
┌─toDateTimeOrDefault('2022-12-30 13:44:17')─┬─toDateTimeOrDefault('', 'UTC', CAST('2023-01-01', 'DateTime(\'UTC\')'))─┐
│ 2022-12-30 13:44:17 │ 2023-01-01 00:00:00 │
└────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────┘
toDate32
将参数转换为 Date32 数据类型。如果值超出范围，则 toDate32 返回 Date32 支持的边界值。如果参数具有 Date 类型，则会考虑其边界。
语法
toDate32(expr)
参数
返回值
- 日历日期。类型 Date32。
示例
- 值在范围内
SELECT toDate32('1955-01-01') AS value, toTypeName(value);
┌──────value─┬─toTypeName(toDate32('1925-01-01'))─┐
│ 1955-01-01 │ Date32 │
└────────────┴────────────────────────────────────┘
- 值超出范围
SELECT toDate32('1899-01-01') AS value, toTypeName(value);
┌──────value─┬─toTypeName(toDate32('1899-01-01'))─┐
│ 1900-01-01 │ Date32 │
└────────────┴────────────────────────────────────┘
- 使用 Date 参数
SELECT toDate32(toDate('1899-01-01')) AS value, toTypeName(value);
┌──────value─┬─toTypeName(toDate32(toDate('1899-01-01')))─┐
│ 1970-01-01 │ Date32 │
└────────────┴────────────────────────────────────────────┘
toDate32OrZero
与 toDate32 相同，但如果收到无效参数，则返回 Date32 的最小值。
示例
查询
SELECT toDate32OrZero('1899-01-01'), toDate32OrZero('');
结果
┌─toDate32OrZero('1899-01-01')─┬─toDate32OrZero('')─┐
│ 1900-01-01 │ 1900-01-01 │
└──────────────────────────────┴────────────────────┘
toDate32OrNull
与 toDate32 相同，但如果收到无效参数，则返回 NULL。
示例
查询
SELECT toDate32OrNull('1955-01-01'), toDate32OrNull('');
结果
┌─toDate32OrNull('1955-01-01')─┬─toDate32OrNull('')─┐
│ 1955-01-01 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴────────────────────┘
toDate32OrDefault
将参数转换为 Date32 数据类型。如果值超出范围，则 toDate32OrDefault 返回 Date32 支持的下边界值。如果参数具有 Date 类型，则会考虑其边界。如果收到无效参数，则返回默认值。
示例
查询
SELECT
toDate32OrDefault('1930-01-01', toDate32('2020-01-01')),
toDate32OrDefault('xx1930-01-01', toDate32('2020-01-01'));
结果
┌─toDate32OrDefault('1930-01-01', toDate32('2020-01-01'))─┬─toDate32OrDefault('xx1930-01-01', toDate32('2020-01-01'))─┐
│ 1930-01-01 │ 2020-01-01 │
└─────────────────────────────────────────────────────────┴───────────────────────────────────────────────────────────┘
toDateTime64
将输入值转换为 DateTime64 类型的值。
语法
toDateTime64(expr, scale, [timezone])
参数
expr— 值。 String、UInt32、Float 或 DateTime。scale- 刻度大小（精度）：10-precision 秒。有效范围[ 0 : 9 ].timezone（可选） - 指定的 datetime64 对象的时区。
返回值
- 日历日期和时间，具有亚秒精度。 DateTime64。
示例
- 值在范围内
SELECT toDateTime64('1955-01-01 00:00:00.000', 3) AS value, toTypeName(value);
┌───────────────────value─┬─toTypeName(toDateTime64('1955-01-01 00:00:00.000', 3))─┐
│ 1955-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────────────────┘
- 作为带精度的十进制数
SELECT toDateTime64(1546300800.000, 3) AS value, toTypeName(value);
┌───────────────────value─┬─toTypeName(toDateTime64(1546300800., 3))─┐
│ 2019-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴──────────────────────────────────────────┘
没有小数点，该值仍被视为以秒为单位的 Unix 时间戳
SELECT toDateTime64(1546300800000, 3) AS value, toTypeName(value);
┌───────────────────value─┬─toTypeName(toDateTime64(1546300800000, 3))─┐
│ 2282-12-31 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────┘
- 使用
timezone
SELECT toDateTime64('2019-01-01 00:00:00', 3, 'Asia/Istanbul') AS value, toTypeName(value);
┌───────────────────value─┬─toTypeName(toDateTime64('2019-01-01 00:00:00', 3, 'Asia/Istanbul'))─┐
│ 2019-01-01 00:00:00.000 │ DateTime64(3, 'Asia/Istanbul') │
└─────────────────────────┴─────────────────────────────────────────────────────────────────────┘
toDateTime64OrZero
与 toDateTime64 类似，此函数将输入值转换为 DateTime64 类型的值，但如果收到无效参数，则返回 DateTime64 的最小值。
语法
toDateTime64OrZero(expr, scale, [timezone])
参数
expr— 值。 String、UInt32、Float 或 DateTime。scale- 刻度大小（精度）：10-precision 秒。有效范围[ 0 : 9 ].timezone（可选） - 指定的 DateTime64 对象的时区。
返回值
- 日历日期和时间，具有亚秒精度，否则为
DateTime64的最小值：1970-01-01 01:00:00.000。 DateTime64。
示例
查询
SELECT toDateTime64OrZero('2008-10-12 00:00:00 00:30:30', 3) AS invalid_arg
结果
┌─────────────invalid_arg─┐
│ 1970-01-01 01:00:00.000 │
└─────────────────────────┘
另请参阅
toDateTime64OrNull
与 toDateTime64 类似，此函数将输入值转换为 DateTime64 类型的值，但如果收到无效参数，则返回 NULL。
语法
toDateTime64OrNull(expr, scale, [timezone])
参数
expr— 值。 String、UInt32、Float 或 DateTime。scale- 刻度大小（精度）：10-precision 秒。有效范围[ 0 : 9 ].timezone（可选） - 指定的 DateTime64 对象的时区。
返回值
- 日历日期和时间，具有亚秒精度，否则为
NULL。 DateTime64/NULL。
示例
查询
SELECT
toDateTime64OrNull('1976-10-18 00:00:00.30', 3) AS valid_arg,
toDateTime64OrNull('1976-10-18 00:00:00 30', 3) AS invalid_arg
结果
┌───────────────valid_arg─┬─invalid_arg─┐
│ 1976-10-18 00:00:00.300 │ ᴺᵁᴸᴸ │
└─────────────────────────┴─────────────┘
另请参阅
toDateTime64OrDefault
与 toDateTime64 类似，此函数将输入值转换为 DateTime64 类型的值，但如果收到无效参数，则返回 DateTime64 的默认值或提供的默认值。
语法
toDateTime64OrNull(expr, scale, [timezone, default])
参数
expr— 值。 String、UInt32、Float 或 DateTime。scale- 刻度大小（精度）：10-precision 秒。有效范围[ 0 : 9 ].timezone（可选） - 指定的 DateTime64 对象的时区。default（可选） - 如果收到无效参数，则返回的默认值。 DateTime64。
返回值
- 日历日期和时间，具有亚秒精度，否则为
DateTime64的最小值或提供的default值。 DateTime64。
示例
查询
SELECT
toDateTime64OrDefault('1976-10-18 00:00:00 30', 3) AS invalid_arg,
toDateTime64OrDefault('1976-10-18 00:00:00 30', 3, 'UTC', toDateTime64('2001-01-01 00:00:00.00',3)) AS invalid_arg_with_default
结果
┌─────────────invalid_arg─┬─invalid_arg_with_default─┐
│ 1970-01-01 01:00:00.000 │ 2000-12-31 23:00:00.000 │
└─────────────────────────┴──────────────────────────┘
另请参阅
toDecimal32
将输入值转换为 Decimal(9, S) 类型的值，其中比例为 S。如果发生错误，则抛出异常。
语法
toDecimal32(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的值或字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf（不区分大小写）的值或字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
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。您可以使用字符串输入，以便操作使用底层整数类型：toDecimal32('1.15', 2) = 1.15
返回值
Decimal(9, S)类型的值。 Decimal32(S)。
示例
查询
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;
结果
Row 1:
──────
a: 2
type_a: Decimal(9, 1)
b: 4.2
type_b: Decimal(9, 2)
c: 4.2
type_c: Decimal(9, 3)
另请参阅
toDecimal32OrZero
与 toDecimal32 类似，此函数将输入值转换为 Decimal(9, S) 类型的值，但在发生错误时返回 0。
语法
toDecimal32OrZero(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal32OrZero('0xc0fe', 1);。
如果 expr 的值超过 Decimal32 的范围，则可能发生溢出：( -1 * 10^(9 - S), 1 * 10^(9 - S) )。小数部分的额外数字将被丢弃（不会舍入）。整数部分的额外数字将导致错误。
返回值
- 如果成功，则为
Decimal(9, S)类型的值，否则为具有S个小数位的0。 Decimal32(S)。
示例
查询
SELECT
toDecimal32OrZero(toString(-1.111), 5) AS a,
toTypeName(a),
toDecimal32OrZero(toString('Inf'), 5) as b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: -1.111
toTypeName(a): Decimal(9, 5)
b: 0
toTypeName(b): Decimal(9, 5)
另请参阅
toDecimal32OrNull
与 toDecimal32 类似，此函数将输入值转换为 Nullable(Decimal(9, S)) 类型的值，但在发生错误时返回 0。
语法
toDecimal32OrNull(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal32OrNull('0xc0fe', 1);。
如果 expr 的值超过 Decimal32 的范围，则可能发生溢出：( -1 * 10^(9 - S), 1 * 10^(9 - S) )。小数部分的额外数字将被丢弃（不会舍入）。整数部分的额外数字将导致错误。
返回值
- 如果成功，则为
Nullable(Decimal(9, S))类型的值，否则为相同类型的NULL值。 Decimal32(S)。
示例
查询
SELECT
toDecimal32OrNull(toString(-1.111), 5) AS a,
toTypeName(a),
toDecimal32OrNull(toString('Inf'), 5) as b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: -1.111
toTypeName(a): Nullable(Decimal(9, 5))
b: ᴺᵁᴸᴸ
toTypeName(b): Nullable(Decimal(9, 5))
另请参阅
toDecimal32OrDefault
与 toDecimal32 类似，此函数将输入值转换为 Decimal(9, S) 类型的值，但在发生错误时返回默认值。
语法
toDecimal32OrDefault(expr, S[, default])
参数
expr— 数字的字符串表示形式。 String。S— 介于 0 和 9 之间的比例参数，指定数字小数部分可以有多少位数字。 UInt8。default（可选） — 如果解析为Decimal32(S)类型不成功，则返回的默认值。 Decimal32(S)。
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal32OrDefault('0xc0fe', 1);。
如果 expr 的值超过 Decimal32 的范围，则可能发生溢出：( -1 * 10^(9 - S), 1 * 10^(9 - S) )。小数部分的额外数字将被丢弃（不会舍入）。整数部分的额外数字将导致错误。
转换会丢弃额外的数字，并且在使用 Float32/Float64 输入时可能会以意外的方式运行，因为操作是使用浮点指令执行的。例如：toDecimal32OrDefault(1.15, 2) 等于 1.14，因为在浮点数中 1.15 * 100 为 114.99。您可以使用字符串输入，以便操作使用底层整数类型：toDecimal32OrDefault('1.15', 2) = 1.15
返回值
- 如果成功，则为
Decimal(9, S)类型的值，否则如果传递则返回默认值，否则返回0。 Decimal32(S)。
示例
查询
SELECT
toDecimal32OrDefault(toString(0.0001), 5) AS a,
toTypeName(a),
toDecimal32OrDefault('Inf', 0, CAST('-1', 'Decimal32(0)')) AS b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.0001
toTypeName(a): Decimal(9, 5)
b: -1
toTypeName(b): Decimal(9, 0)
另请参阅
toDecimal64
将输入值转换为 Decimal(18, S) 类型的值，其中比例为 S。如果发生错误，则抛出异常。
语法
toDecimal64(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的值或字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf（不区分大小写）的值或字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
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
返回值
Decimal(18, S)类型的值。 Decimal64(S)。
示例
查询
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;
结果
Row 1:
──────
a: 2
type_a: Decimal(18, 1)
b: 4.2
type_b: Decimal(18, 2)
c: 4.2
type_c: Decimal(18, 3)
另请参阅
toDecimal64OrZero
类似于 toDecimal64，此函数将输入值转换为 Decimal(18, S) 类型的值，但在发生错误时返回 0。
语法
toDecimal64OrZero(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal64OrZero('0xc0fe', 1);。
如果 expr 的值超过 Decimal64 的范围：( -1 * 10^(18 - S), 1 * 10^(18 - S) )，则可能发生溢出。小数部分的过长数字将被丢弃（不会进行四舍五入）。整数部分的过长数字将导致错误。
返回值
- 如果成功，则为
Decimal(18, S)类型的值，否则为带有S位小数的0。 Decimal64(S)。
示例
查询
SELECT
toDecimal64OrZero(toString(0.0001), 18) AS a,
toTypeName(a),
toDecimal64OrZero(toString('Inf'), 18) as b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.0001
toTypeName(a): Decimal(18, 18)
b: 0
toTypeName(b): Decimal(18, 18)
另请参阅
toDecimal64OrNull
类似于 toDecimal64，此函数将输入值转换为 Nullable(Decimal(18, S)) 类型的值，但在发生错误时返回 0。
语法
toDecimal64OrNull(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal64OrNull('0xc0fe', 1);。
如果 expr 的值超过 Decimal64 的范围：( -1 * 10^(18 - S), 1 * 10^(18 - S) )，则可能发生溢出。小数部分的过长数字将被丢弃（不会进行四舍五入）。整数部分的过长数字将导致错误。
返回值
- 如果成功，则为
Nullable(Decimal(18, S))类型的值，否则为相同类型的NULL值。 Decimal64(S)。
示例
查询
SELECT
toDecimal64OrNull(toString(0.0001), 18) AS a,
toTypeName(a),
toDecimal64OrNull(toString('Inf'), 18) as b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.0001
toTypeName(a): Nullable(Decimal(18, 18))
b: ᴺᵁᴸᴸ
toTypeName(b): Nullable(Decimal(18, 18))
另请参阅
toDecimal64OrDefault
类似于 toDecimal64，此函数将输入值转换为 Decimal(18, S) 类型的值，但在发生错误时返回默认值。
语法
toDecimal64OrDefault(expr, S[, default])
参数
expr— 数字的字符串表示形式。 String。S— 介于 0 和 18 之间的比例参数，指定数字小数部分可以有多少位数字。 UInt8。default（可选）— 如果解析为Decimal64(S)类型不成功，则返回的默认值。 Decimal64(S)。
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal64OrDefault('0xc0fe', 1);。
如果 expr 的值超过 Decimal64 的范围：( -1 * 10^(18 - S), 1 * 10^(18 - S) )，则可能发生溢出。小数部分的过长数字将被丢弃（不会进行四舍五入）。整数部分的过长数字将导致错误。
转换会丢弃多余的数字，并且在使用 Float32/Float64 输入时可能会以意外的方式运行，因为操作是使用浮点指令执行的。例如：toDecimal64OrDefault(1.15, 2) 等于 1.14，因为浮点数中的 1.15 * 100 为 114.99。您可以使用字符串输入，以便操作使用底层整数类型：toDecimal64OrDefault('1.15', 2) = 1.15
返回值
- 如果成功，则为
Decimal(18, S)类型的值，否则如果传递则返回默认值，否则返回0。 Decimal64(S)。
示例
查询
SELECT
toDecimal64OrDefault(toString(0.0001), 18) AS a,
toTypeName(a),
toDecimal64OrDefault('Inf', 0, CAST('-1', 'Decimal64(0)')) AS b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.0001
toTypeName(a): Decimal(18, 18)
b: -1
toTypeName(b): Decimal(18, 0)
另请参阅
toDecimal128
将输入值转换为 Decimal(38, S) 类型的值，比例为 S。在发生错误时抛出异常。
语法
toDecimal128(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的值或字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf（不区分大小写）的值或字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
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
返回值
Decimal(38, S)类型的值。 Decimal128(S)。
示例
查询
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;
结果
Row 1:
──────
a: 99
type_a: Decimal(38, 1)
b: 99.67
type_b: Decimal(38, 2)
c: 99.67
type_c: Decimal(38, 3)
另请参阅
toDecimal128OrZero
类似于 toDecimal128，此函数将输入值转换为 Decimal(38, S) 类型的值，但在发生错误时返回 0。
语法
toDecimal128OrZero(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal128OrZero('0xc0fe', 1);。
如果 expr 的值超过 Decimal128 的范围：( -1 * 10^(38 - S), 1 * 10^(38 - S) )，则可能发生溢出。小数部分的过长数字将被丢弃（不会进行四舍五入）。整数部分的过长数字将导致错误。
返回值
- 如果成功，则为
Decimal(38, S)类型的值，否则为带有S位小数的0。 Decimal128(S)。
示例
查询
SELECT
toDecimal128OrZero(toString(0.0001), 38) AS a,
toTypeName(a),
toDecimal128OrZero(toString('Inf'), 38) as b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.0001
toTypeName(a): Decimal(38, 38)
b: 0
toTypeName(b): Decimal(38, 38)
另请参阅
toDecimal128OrNull
类似于 toDecimal128，此函数将输入值转换为 Nullable(Decimal(38, S)) 类型的值，但在发生错误时返回 0。
语法
toDecimal128OrNull(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal128OrNull('0xc0fe', 1);。
如果 expr 的值超过 Decimal128 的范围：( -1 * 10^(38 - S), 1 * 10^(38 - S) )，则可能发生溢出。小数部分的过长数字将被丢弃（不会进行四舍五入）。整数部分的过长数字将导致错误。
返回值
- 如果成功，则为
Nullable(Decimal(38, S))类型的值，否则为相同类型的NULL值。 Decimal128(S)。
示例
查询
SELECT
toDecimal128OrNull(toString(1/42), 38) AS a,
toTypeName(a),
toDecimal128OrNull(toString('Inf'), 38) as b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.023809523809523808
toTypeName(a): Nullable(Decimal(38, 38))
b: ᴺᵁᴸᴸ
toTypeName(b): Nullable(Decimal(38, 38))
另请参阅
toDecimal128OrDefault
类似于 toDecimal128，此函数将输入值转换为 Decimal(38, S) 类型的值，但在发生错误时返回默认值。
语法
toDecimal128OrDefault(expr, S[, default])
参数
expr— 数字的字符串表示形式。 String。S— 0 到 38 之间的比例参数，指定数字小数部分可以有多少位数字。 UInt8。default（可选）— 如果解析为Decimal128(S)类型不成功，则返回的默认值。 Decimal128(S)。
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal128OrDefault('0xc0fe', 1);。
如果 expr 的值超过 Decimal128 的范围：( -1 * 10^(38 - S), 1 * 10^(38 - S) )，则可能发生溢出。小数部分的过长数字将被丢弃（不会进行四舍五入）。整数部分的过长数字将导致错误。
转换会丢弃多余的数字，并且在使用 Float32/Float64 输入时可能会以意外的方式运行，因为操作是使用浮点指令执行的。例如：toDecimal128OrDefault(1.15, 2) 等于 1.14，因为浮点数中的 1.15 * 100 为 114.99。您可以使用字符串输入，以便操作使用底层整数类型：toDecimal128OrDefault('1.15', 2) = 1.15
返回值
- 如果成功，则为
Decimal(38, S)类型的值，否则如果传递则返回默认值，否则返回0。 Decimal128(S)。
示例
查询
SELECT
toDecimal128OrDefault(toString(1/42), 18) AS a,
toTypeName(a),
toDecimal128OrDefault('Inf', 0, CAST('-1', 'Decimal128(0)')) AS b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.023809523809523808
toTypeName(a): Decimal(38, 18)
b: -1
toTypeName(b): Decimal(38, 0)
另请参阅
toDecimal256
将输入值转换为 Decimal(76, S) 类型的值，比例为 S。在发生错误时抛出异常。
语法
toDecimal256(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的数值或字符串表示形式。
- Float32/64 类型的值或字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf（不区分大小写）的值或字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
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
返回值
Decimal(76, S)类型的值。 Decimal256(S)。
示例
查询
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;
结果
Row 1:
──────
a: 99
type_a: Decimal(76, 1)
b: 99.67
type_b: Decimal(76, 2)
c: 99.67
type_c: Decimal(76, 3)
另请参阅
toDecimal256OrZero
类似于 toDecimal256，此函数将输入值转换为 Decimal(76, S) 类型的值，但在发生错误时返回 0。
语法
toDecimal256OrZero(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal256OrZero('0xc0fe', 1);。
如果 expr 的值超过 Decimal256 的范围：( -1 * 10^(76 - S), 1 * 10^(76 - S) )，则可能发生溢出。小数部分的过长数字将被丢弃（不会进行四舍五入）。整数部分的过长数字将导致错误。
返回值
- 如果成功，则为
Decimal(76, S)类型的值，否则为带有S位小数的0。 Decimal256(S)。
示例
查询
SELECT
toDecimal256OrZero(toString(0.0001), 76) AS a,
toTypeName(a),
toDecimal256OrZero(toString('Inf'), 76) as b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.0001
toTypeName(a): Decimal(76, 76)
b: 0
toTypeName(b): Decimal(76, 76)
另请参阅
toDecimal256OrNull
类似于 toDecimal256，此函数将输入值转换为 Nullable(Decimal(76, S)) 类型的值，但在发生错误时返回 0。
语法
toDecimal256OrNull(expr, S)
参数
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal256OrNull('0xc0fe', 1);。
如果 expr 的值超过 Decimal256 的范围：( -1 * 10^(76 - S), 1 * 10^(76 - S) )，则可能发生溢出。小数部分的过长数字将被丢弃（不会进行四舍五入）。整数部分的过长数字将导致错误。
返回值
- 如果成功，则为
Nullable(Decimal(76, S))类型的值，否则为相同类型的NULL值。 Decimal256(S)。
示例
查询
SELECT
toDecimal256OrNull(toString(1/42), 76) AS a,
toTypeName(a),
toDecimal256OrNull(toString('Inf'), 76) as b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.023809523809523808
toTypeName(a): Nullable(Decimal(76, 76))
b: ᴺᵁᴸᴸ
toTypeName(b): Nullable(Decimal(76, 76))
另请参阅
toDecimal256OrDefault
类似于 toDecimal256，此函数将输入值转换为 Decimal(76, S) 类型的值，但在发生错误时返回默认值。
语法
toDecimal256OrDefault(expr, S[, default])
参数
expr— 数字的字符串表示形式。 String。S— 0 到 76 之间的比例参数，指定数字小数部分可以有多少位数字。 UInt8。default（可选）— 如果解析为Decimal256(S)类型不成功，则返回的默认值。 Decimal256(S)。
支持的参数
- (U)Int8/16/32/64/128/256 类型的字符串表示形式。
- Float32/64 类型的字符串表示形式。
不支持的参数
- Float32/64 值
NaN和Inf的字符串表示形式。 - 二进制和十六进制值的字符串表示形式，例如
SELECT toDecimal256OrDefault('0xc0fe', 1);。
如果 expr 的值超过 Decimal256 的范围：( -1 * 10^(76 - S), 1 * 10^(76 - S) )，则可能发生溢出。小数部分的过长数字将被丢弃（不会进行四舍五入）。整数部分的过长数字将导致错误。
转换会丢弃多余的数字，并且在使用 Float32/Float64 输入时可能会以意外的方式运行，因为操作是使用浮点指令执行的。例如：toDecimal256OrDefault(1.15, 2) 等于 1.14，因为浮点数中的 1.15 * 100 为 114.99。您可以使用字符串输入，以便操作使用底层整数类型：toDecimal256OrDefault('1.15', 2) = 1.15
返回值
- 如果成功，则为
Decimal(76, S)类型的值，否则如果传递则返回默认值，否则返回0。 Decimal256(S)。
示例
查询
SELECT
toDecimal256OrDefault(toString(1/42), 76) AS a,
toTypeName(a),
toDecimal256OrDefault('Inf', 0, CAST('-1', 'Decimal256(0)')) AS b,
toTypeName(b)
FORMAT Vertical;
结果
Row 1:
──────
a: 0.023809523809523808
toTypeName(a): Decimal(76, 76)
b: -1
toTypeName(b): Decimal(76, 0)
另请参阅
toString
用于在数字、字符串（但不包括固定字符串）、日期和日期时间之间进行转换的函数。所有这些函数都接受一个参数。
在转换为或从字符串转换时，将使用与 TabSeparated 格式（以及几乎所有其他文本格式）相同的规则来格式化或解析值。如果无法解析字符串，则会抛出异常并取消请求。
在将日期转换为数字或反之亦然时，日期对应于自 Unix 纪元开始以来的天数。在将日期时间转换为数字或反之亦然时，日期时间对应于自 Unix 纪元开始以来的秒数。
toDate/toDateTime 函数的日期和日期时间格式定义如下
YYYY-MM-DD
YYYY-MM-DD hh:mm:ss
作为例外，如果从 UInt32、Int32、UInt64 或 Int64 数值类型转换为 Date，并且如果数字大于或等于 65536，则该数字将被解释为 Unix 时间戳（而不是天数），并四舍五入到日期。这允许支持常见的编写 toDate(unix_timestamp) 的情况，否则这将是一个错误，需要编写更繁琐的 toDate(toDateTime(unix_timestamp))。
在日期和日期时间之间进行转换以自然的方式执行：通过添加空时间或删除时间。
数值类型之间的转换使用与 C++ 中不同数值类型之间的赋值相同的规则。
此外，DateTime 参数的 toString 函数可以接受第二个 String 类型的参数，该参数包含时区的名称。例如：Asia/Yekaterinburg 在这种情况下，时间将根据指定的时区进行格式化。
示例
查询
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
结果
┌──────────────────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 │
│ 2023-09-08 19:14:59 │ Europe/Belgrade │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Berlin │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Bratislava │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Brussels │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Bucharest │ 2023-09-08 22:14:59 │
└─────────────────────┴───────────────────┴─────────────────────┘
另请参见 toUnixTimestamp 函数。
toFixedString
将 String 类型的参数转换为 FixedString(N) 类型（长度为 N 的固定长度字符串）。如果字符串的字节数少于 N，则在右侧用空字节填充。如果字符串的字节数大于 N，则会抛出异常。
语法
toFixedString(s, N)
参数
返回值
- 长度为 N 的
s的固定字符串。 FixedString。
示例
查询
SELECT toFixedString('foo', 8) AS s;
结果
┌─s─────────────┐
│ foo\0\0\0\0\0 │
└───────────────┘
toStringCutToZero
接受 String 或 FixedString 参数。返回在找到第一个零字节处截断内容的字符串。
语法
toStringCutToZero(s)
示例
查询
SELECT toFixedString('foo', 8) AS s, toStringCutToZero(s) AS s_cut;
结果
┌─s─────────────┬─s_cut─┐
│ foo\0\0\0\0\0 │ foo │
└───────────────┴───────┘
查询
SELECT toFixedString('foo\0bar', 8) AS s, toStringCutToZero(s) AS s_cut;
结果
┌─s──────────┬─s_cut─┐
│ foo\0bar\0 │ foo │
└────────────┴───────┘
toDecimalString
将数值转换为字符串，输出的小数位数由用户指定。
语法
toDecimalString(number, scale)
参数
返回值
- 输入值表示为 String，并具有指定的小数位数（刻度）。如果请求的刻度小于原始数字的刻度，则根据常用算术进行四舍五入。
示例
查询
SELECT toDecimalString(CAST('64.32', 'Float64'), 5);
结果
┌toDecimalString(CAST('64.32', 'Float64'), 5)─┐
│ 64.32000 │
└─────────────────────────────────────────────┘
reinterpretAsUInt8
通过将输入值视为 UInt8 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsUInt8(x)
参数
返回值
- 将
x重新解释为 UInt8。 UInt8。
示例
查询
SELECT
toInt8(257) AS x,
toTypeName(x),
reinterpretAsUInt8(x) AS res,
toTypeName(res);
结果
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ Int8 │ 1 │ UInt8 │
└───┴───────────────┴─────┴─────────────────┘
reinterpretAsUInt16
通过将输入值视为 UInt16 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsUInt16(x)
参数
返回值
- 将
x重新解释为 UInt16。 UInt16。
示例
查询
SELECT
toUInt8(257) AS x,
toTypeName(x),
reinterpretAsUInt16(x) AS res,
toTypeName(res);
结果
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ UInt8 │ 1 │ UInt16 │
└───┴───────────────┴─────┴─────────────────┘
reinterpretAsUInt32
通过将输入值视为 UInt32 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsUInt32(x)
参数
返回值
- 将
x重新解释为 UInt32。 UInt32。
示例
查询
SELECT
toUInt16(257) AS x,
toTypeName(x),
reinterpretAsUInt32(x) AS res,
toTypeName(res)
结果
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt16 │ 257 │ UInt32 │
└─────┴───────────────┴─────┴─────────────────┘
reinterpretAsUInt64
通过将输入值视为 UInt64 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsUInt64(x)
参数
返回值
- 将
x重新解释为 UInt64。 UInt64。
示例
查询
SELECT
toUInt32(257) AS x,
toTypeName(x),
reinterpretAsUInt64(x) AS res,
toTypeName(res)
结果
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt32 │ 257 │ UInt64 │
└─────┴───────────────┴─────┴─────────────────┘
reinterpretAsUInt128
通过将输入值视为 UInt128 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsUInt128(x)
参数
返回值
- 将
x重新解释为 UInt128。 UInt128。
示例
查询
SELECT
toUInt64(257) AS x,
toTypeName(x),
reinterpretAsUInt128(x) AS res,
toTypeName(res)
结果
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt64 │ 257 │ UInt128 │
└─────┴───────────────┴─────┴─────────────────┘
reinterpretAsUInt256
通过将输入值视为 UInt256 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsUInt256(x)
参数
返回值
- 将
x重新解释为 UInt256。 UInt256。
示例
查询
SELECT
toUInt128(257) AS x,
toTypeName(x),
reinterpretAsUInt256(x) AS res,
toTypeName(res)
结果
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt128 │ 257 │ UInt256 │
└─────┴───────────────┴─────┴─────────────────┘
reinterpretAsInt8
通过将输入值视为 Int8 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsInt8(x)
参数
返回值
- 将
x重新解释为 Int8。 Int8。
示例
查询
SELECT
toUInt8(257) AS x,
toTypeName(x),
reinterpretAsInt8(x) AS res,
toTypeName(res);
结果
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ UInt8 │ 1 │ Int8 │
└───┴───────────────┴─────┴─────────────────┘
reinterpretAsInt16
通过将输入值视为 Int16 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsInt16(x)
参数
返回值
- 将
x重新解释为 Int16。 Int16。
示例
查询
SELECT
toInt8(257) AS x,
toTypeName(x),
reinterpretAsInt16(x) AS res,
toTypeName(res);
结果
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ Int8 │ 1 │ Int16 │
└───┴───────────────┴─────┴─────────────────┘
reinterpretAsInt32
通过将输入值视为 Int32 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsInt32(x)
参数
返回值
- 将
x重新解释为 Int32。 Int32。
示例
查询
SELECT
toInt16(257) AS x,
toTypeName(x),
reinterpretAsInt32(x) AS res,
toTypeName(res);
结果
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int16 │ 257 │ Int32 │
└─────┴───────────────┴─────┴─────────────────┘
reinterpretAsInt64
通过将输入值视为 Int64 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsInt64(x)
参数
返回值
- 将
x重新解释为 Int64。 Int64。
示例
查询
SELECT
toInt32(257) AS x,
toTypeName(x),
reinterpretAsInt64(x) AS res,
toTypeName(res);
结果
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int32 │ 257 │ Int64 │
└─────┴───────────────┴─────┴─────────────────┘
reinterpretAsInt128
通过将输入值视为 Int128 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsInt128(x)
参数
返回值
- 将
x重新解释为 Int128。 Int128。
示例
查询
SELECT
toInt64(257) AS x,
toTypeName(x),
reinterpretAsInt128(x) AS res,
toTypeName(res);
结果
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int64 │ 257 │ Int128 │
└─────┴───────────────┴─────┴─────────────────┘
reinterpretAsInt256
通过将输入值视为 Int256 类型的值来执行字节重新解释。与 CAST 不同，该函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsInt256(x)
参数
返回值
- 将
x重新解释为 Int256。 Int256。
示例
查询
SELECT
toInt128(257) AS x,
toTypeName(x),
reinterpretAsInt256(x) AS res,
toTypeName(res);
结果
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int128 │ 257 │ Int256 │
└─────┴───────────────┴─────┴─────────────────┘
reinterpretAsFloat32
将输入值视为 Float32 类型的值进行字节重新解释。与 CAST 不同，此函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsFloat32(x)
参数
返回值
- 将
x重新解释为 Float32 的值。 Float32。
示例
查询
SELECT reinterpretAsUInt32(toFloat32(0.2)) as x, reinterpretAsFloat32(x);
结果
┌──────────x─┬─reinterpretAsFloat32(x)─┐
│ 1045220557 │ 0.2 │
└────────────┴─────────────────────────┘
reinterpretAsFloat64
将输入值视为 Float64 类型的值进行字节重新解释。与 CAST 不同，此函数不会尝试保留原始值 - 如果目标类型无法表示输入类型，则输出将毫无意义。
语法
reinterpretAsFloat64(x)
参数
返回值
- 将
x重新解释为 Float64 的值。 Float64。
示例
查询
SELECT reinterpretAsUInt64(toFloat64(0.2)) as x, reinterpretAsFloat64(x);
结果
┌───────────────────x─┬─reinterpretAsFloat64(x)─┐
│ 4596373779694328218 │ 0.2 │
└─────────────────────┴─────────────────────────┘
reinterpretAsDate
接受字符串、固定字符串或数值，并将字节解释为主机字节序（小端）的数字。它根据解释后的数字返回日期，该数字表示自 Unix 纪元开始的天数。
语法
reinterpretAsDate(x)
参数
返回值
- 日期。 Date。
实现细节
如果提供的字符串不够长，则函数的行为就像字符串用必要的空字节填充一样。如果字符串比需要长，则忽略额外的字节。
示例
查询
SELECT reinterpretAsDate(65), reinterpretAsDate('A');
结果
┌─reinterpretAsDate(65)─┬─reinterpretAsDate('A')─┐
│ 1970-03-07 │ 1970-03-07 │
└───────────────────────┴────────────────────────┘
reinterpretAsDateTime
这些函数接受一个字符串，并将字符串开头处的字节解释为主机字节序（小端）的数字。返回带有时间的日期，该日期解释为自 Unix 纪元开始的秒数。
语法
reinterpretAsDateTime(x)
参数
返回值
- 日期和时间。 DateTime。
实现细节
如果提供的字符串不够长，则函数的行为就像字符串用必要的空字节填充一样。如果字符串比需要长，则忽略额外的字节。
示例
查询
SELECT reinterpretAsDateTime(65), reinterpretAsDateTime('A');
结果
┌─reinterpretAsDateTime(65)─┬─reinterpretAsDateTime('A')─┐
│ 1970-01-01 01:01:05 │ 1970-01-01 01:01:05 │
└───────────────────────────┴────────────────────────────┘
reinterpretAsString
此函数接受数字、日期或带有时间的日期，并返回一个包含表示相应值的主机字节序（小端）的字节的字符串。结尾处的空字节将被删除。例如，UInt32 类型值为 255 的字符串长度为 1 个字节。
语法
reinterpretAsString(x)
参数
返回值
- 包含表示
x的字节的字符串。 String。
示例
查询
SELECT
reinterpretAsString(toDateTime('1970-01-01 01:01:05')),
reinterpretAsString(toDate('1970-03-07'));
结果
┌─reinterpretAsString(toDateTime('1970-01-01 01:01:05'))─┬─reinterpretAsString(toDate('1970-03-07'))─┐
│ A │ A │
└────────────────────────────────────────────────────────┴───────────────────────────────────────────┘
reinterpretAsFixedString
此函数接受数字、日期或带有时间的日期，并返回一个包含表示相应值的主机字节序（小端）的字节的 FixedString。结尾处的空字节将被删除。例如，UInt32 类型值为 255 的 FixedString 长度为 1 个字节。
语法
reinterpretAsFixedString(x)
参数
返回值
- 包含表示
x的字节的固定字符串。 FixedString。
示例
查询
SELECT
reinterpretAsFixedString(toDateTime('1970-01-01 01:01:05')),
reinterpretAsFixedString(toDate('1970-03-07'));
结果
┌─reinterpretAsFixedString(toDateTime('1970-01-01 01:01:05'))─┬─reinterpretAsFixedString(toDate('1970-03-07'))─┐
│ A │ A │
└─────────────────────────────────────────────────────────────┴────────────────────────────────────────────────┘
reinterpretAsUUID
除了此处列出的 UUID 函数外，还有专门的 UUID 函数文档。
接受一个 16 字节的字符串，并返回一个包含表示相应值的网络字节序（大端）的字节的 UUID。如果字符串不够长，则函数的行为就像字符串用必要的空字节填充到末尾一样。如果字符串长度超过 16 个字节，则忽略末尾的额外字节。
语法
reinterpretAsUUID(fixed_string)
参数
fixed_string- 大端字节字符串。 FixedString。
返回值
- UUID 类型值。 UUID。
示例
字符串到 UUID。
查询
SELECT reinterpretAsUUID(reverse(unhex('000102030405060708090a0b0c0d0e0f')));
结果
┌─reinterpretAsUUID(reverse(unhex('000102030405060708090a0b0c0d0e0f')))─┐
│ 08090a0b-0c0d-0e0f-0001-020304050607 │
└───────────────────────────────────────────────────────────────────────┘
在字符串和 UUID 之间来回转换。
查询
WITH
generateUUIDv4() AS uuid,
identity(lower(hex(reverse(reinterpretAsString(uuid))))) AS str,
reinterpretAsUUID(reverse(unhex(str))) AS uuid2
SELECT uuid = uuid2;
结果
┌─equals(uuid, uuid2)─┐
│ 1 │
└─────────────────────┘
reinterpret
使用 x 值相同的源内存字节序列，并将其重新解释为目标类型。
语法
reinterpret(x, type)
参数
x- 任何类型。type- 目标类型。 String。
返回值
- 目标类型值。
示例
查询
SELECT reinterpret(toInt8(-1), 'UInt8') as int_to_uint,
reinterpret(toInt8(1), 'Float32') as int_to_float,
reinterpret('1', 'UInt32') as string_to_int;
结果
┌─int_to_uint─┬─int_to_float─┬─string_to_int─┐
│ 255 │ 1e-45 │ 49 │
└─────────────┴──────────────┴───────────────┘
CAST
将输入值转换为指定的数据类型。与 reinterpret 函数不同，CAST 尝试使用新的数据类型呈现相同的值。如果无法进行转换，则会引发异常。支持多种语法变体。
语法
CAST(x, T)
CAST(x AS t)
x::t
参数
x- 要转换的值。可以是任何类型。T- 目标数据类型的名称。 String。t- 目标数据类型。
返回值
- 转换后的值。
如果输入值不适合目标类型的范围，则结果会溢出。例如，CAST(-1, 'UInt8') 返回 255。
示例
查询
SELECT
CAST(toInt8(-1), 'UInt8') AS cast_int_to_uint,
CAST(1.5 AS Decimal(3,2)) AS cast_float_to_decimal,
'1'::Int32 AS cast_string_to_int;
结果
┌─cast_int_to_uint─┬─cast_float_to_decimal─┬─cast_string_to_int─┐
│ 255 │ 1.50 │ 1 │
└──────────────────┴───────────────────────┴────────────────────┘
查询
SELECT
'2016-06-15 23:00:00' AS timestamp,
CAST(timestamp AS DateTime) AS datetime,
CAST(timestamp AS Date) AS date,
CAST(timestamp, 'String') AS string,
CAST(timestamp, 'FixedString(22)') AS fixed_string;
结果
┌─timestamp───────────┬────────────datetime─┬───────date─┬─string──────────────┬─fixed_string──────────────┐
│ 2016-06-15 23:00:00 │ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-15 23:00:00 │ 2016-06-15 23:00:00\0\0\0 │
└─────────────────────┴─────────────────────┴────────────┴─────────────────────┴───────────────────────────┘
仅当参数类型为 String 或 FixedString 时，才能转换为 FixedString (N)。
支持类型转换为 Nullable 和反向转换。
示例
查询
SELECT toTypeName(x) FROM t_null;
结果
┌─toTypeName(x)─┐
│ Int8 │
│ Int8 │
└───────────────┘
查询
SELECT toTypeName(CAST(x, 'Nullable(UInt16)')) FROM t_null;
结果
┌─toTypeName(CAST(x, 'Nullable(UInt16)'))─┐
│ Nullable(UInt16) │
│ Nullable(UInt16) │
└─────────────────────────────────────────┘
另请参阅
accurateCast(x, T)
将 x 转换为 T 数据类型。
与 cast 的区别在于，如果类型值 x 不适合类型 T 的范围，则 accurateCast 不允许在转换期间出现数值类型的溢出。例如，accurateCast(-1, 'UInt8') 会抛出异常。
示例
查询
SELECT cast(-1, 'UInt8') as uint8;
结果
┌─uint8─┐
│ 255 │
└───────┘
查询
SELECT accurateCast(-1, 'UInt8') as uint8;
结果
Code: 70. DB::Exception: Received from localhost:9000. DB::Exception: Value in column Int8 cannot be safely converted into type UInt8: While processing accurateCast(-1, 'UInt8') AS uint8.
accurateCastOrNull(x, T)
将输入值 x 转换为指定的数据类型 T。始终返回 Nullable 类型，如果转换后的值在目标类型中不可表示，则返回 NULL。
语法
accurateCastOrNull(x, T)
参数
x- 输入值。T- 返回的数据类型的名称。
返回值
- 转换为指定的数据类型
T的值。
示例
查询
SELECT toTypeName(accurateCastOrNull(5, 'UInt8'));
结果
┌─toTypeName(accurateCastOrNull(5, 'UInt8'))─┐
│ Nullable(UInt8) │
└────────────────────────────────────────────┘
查询
SELECT
accurateCastOrNull(-1, 'UInt8') as uint8,
accurateCastOrNull(128, 'Int8') as int8,
accurateCastOrNull('Test', 'FixedString(2)') as fixed_string;
结果
┌─uint8─┬─int8─┬─fixed_string─┐
│ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │
└───────┴──────┴──────────────┘
accurateCastOrDefault(x, T[, default_value])
将输入值 x 转换为指定的数据类型 T。如果转换后的值在目标类型中不可表示，则返回默认类型值或指定的 default_value。
语法
accurateCastOrDefault(x, T)
参数
x- 输入值。T- 返回的数据类型的名称。default_value- 返回的数据类型的默认值。
返回值
- 转换为指定的数据类型
T的值。
示例
查询
SELECT toTypeName(accurateCastOrDefault(5, 'UInt8'));
结果
┌─toTypeName(accurateCastOrDefault(5, 'UInt8'))─┐
│ UInt8 │
└───────────────────────────────────────────────┘
查询
SELECT
accurateCastOrDefault(-1, 'UInt8') as uint8,
accurateCastOrDefault(-1, 'UInt8', 5) as uint8_default,
accurateCastOrDefault(128, 'Int8') as int8,
accurateCastOrDefault(128, 'Int8', 5) as int8_default,
accurateCastOrDefault('Test', 'FixedString(2)') as fixed_string,
accurateCastOrDefault('Test', 'FixedString(2)', 'Te') as fixed_string_default;
结果
┌─uint8─┬─uint8_default─┬─int8─┬─int8_default─┬─fixed_string─┬─fixed_string_default─┐
│ 0 │ 5 │ 0 │ 5 │ │ Te │
└───────┴───────────────┴──────┴──────────────┴──────────────┴──────────────────────┘
toIntervalYear
返回 n 年的 IntervalYear 类型的时间间隔。
语法
toIntervalYear(n)
参数
返回值
n年的时间间隔。 IntervalYear。
示例
查询
WITH
toDate('2024-06-15') AS date,
toIntervalYear(1) AS interval_to_year
SELECT date + interval_to_year AS result
结果
┌─────result─┐
│ 2025-06-15 │
└────────────┘
toIntervalQuarter
返回 n 个季度的 IntervalQuarter 类型的时间间隔。
语法
toIntervalQuarter(n)
参数
返回值
n个季度的时间间隔。 IntervalQuarter。
示例
查询
WITH
toDate('2024-06-15') AS date,
toIntervalQuarter(1) AS interval_to_quarter
SELECT date + interval_to_quarter AS result
结果
┌─────result─┐
│ 2024-09-15 │
└────────────┘
toIntervalMonth
返回 n 个月的 IntervalMonth 类型的时间间隔。
语法
toIntervalMonth(n)
参数
返回值
n个月的时间间隔。 IntervalMonth。
示例
查询
WITH
toDate('2024-06-15') AS date,
toIntervalMonth(1) AS interval_to_month
SELECT date + interval_to_month AS result
结果
┌─────result─┐
│ 2024-07-15 │
└────────────┘
toIntervalWeek
返回 n 周的 IntervalWeek 类型的时间间隔。
语法
toIntervalWeek(n)
参数
返回值
n周的时间间隔。 IntervalWeek。
示例
查询
WITH
toDate('2024-06-15') AS date,
toIntervalWeek(1) AS interval_to_week
SELECT date + interval_to_week AS result
结果
┌─────result─┐
│ 2024-06-22 │
└────────────┘
toIntervalDay
返回 n 天的 IntervalDay 类型的时间间隔。
语法
toIntervalDay(n)
参数
返回值
n天的时间间隔。 IntervalDay。
示例
查询
WITH
toDate('2024-06-15') AS date,
toIntervalDay(5) AS interval_to_days
SELECT date + interval_to_days AS result
结果
┌─────result─┐
│ 2024-06-20 │
└────────────┘
toIntervalHour
返回 n 小时的 IntervalHour 类型的时间间隔。
语法
toIntervalHour(n)
参数
返回值
n小时的時間間隔。 IntervalHour。
示例
查询
WITH
toDate('2024-06-15') AS date,
toIntervalHour(12) AS interval_to_hours
SELECT date + interval_to_hours AS result
结果
┌──────────────result─┐
│ 2024-06-15 12:00:00 │
└─────────────────────┘
toIntervalMinute
返回 n 分钟的 IntervalMinute 类型的时间间隔。
语法
toIntervalMinute(n)
参数
返回值
- 间隔
n分钟。 IntervalMinute。
示例
查询
WITH
toDate('2024-06-15') AS date,
toIntervalMinute(12) AS interval_to_minutes
SELECT date + interval_to_minutes AS result
结果
┌──────────────result─┐
│ 2024-06-15 00:12:00 │
└─────────────────────┘
toIntervalSecond
返回一个 n 秒的间隔，数据类型为 IntervalSecond。
语法
toIntervalSecond(n)
参数
返回值
- 间隔
n秒。 IntervalSecond。
示例
查询
WITH
toDate('2024-06-15') AS date,
toIntervalSecond(30) AS interval_to_seconds
SELECT date + interval_to_seconds AS result
结果
┌──────────────result─┐
│ 2024-06-15 00:00:30 │
└─────────────────────┘
toIntervalMillisecond
返回一个 n 毫秒的间隔，数据类型为 IntervalMillisecond。
语法
toIntervalMillisecond(n)
参数
返回值
- 间隔
n毫秒。 IntervalMilliseconds。
示例
查询
WITH
toDateTime('2024-06-15') AS date,
toIntervalMillisecond(30) AS interval_to_milliseconds
SELECT date + interval_to_milliseconds AS result
结果
┌──────────────────result─┐
│ 2024-06-15 00:00:00.030 │
└─────────────────────────┘
toIntervalMicrosecond
返回一个 n 微秒的间隔，数据类型为 IntervalMicrosecond。
语法
toIntervalMicrosecond(n)
参数
返回值
- 间隔
n微秒。 IntervalMicrosecond。
示例
查询
WITH
toDateTime('2024-06-15') AS date,
toIntervalMicrosecond(30) AS interval_to_microseconds
SELECT date + interval_to_microseconds AS result
结果
┌─────────────────────result─┐
│ 2024-06-15 00:00:00.000030 │
└────────────────────────────┘
toIntervalNanosecond
返回一个 n 纳秒的间隔，数据类型为 IntervalNanosecond。
语法
toIntervalNanosecond(n)
参数
返回值
- 间隔
n纳秒。 IntervalNanosecond。
示例
查询
WITH
toDateTime('2024-06-15') AS date,
toIntervalNanosecond(30) AS interval_to_nanoseconds
SELECT date + interval_to_nanoseconds AS result
结果
┌────────────────────────result─┐
│ 2024-06-15 00:00:00.000000030 │
└───────────────────────────────┘
parseDateTime
根据 MySQL 格式字符串 将 String 转换为 DateTime。
此函数是函数 formatDateTime 的反向操作。
语法
parseDateTime(str[, format[, timezone]])
参数
str— 要解析的字符串format— 格式字符串。可选。如果未指定，则为%Y-%m-%d %H:%i:%s。timezone— 时区。可选。
返回值
根据 MySQL 样式格式字符串从输入字符串解析的 DateTime 值。
支持的格式说明符
在 formatDateTime 中列出的所有格式说明符，除了
- %Q: 季度 (1-4)
示例
SELECT parseDateTime('2021-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
┌─parseDateTime('2021-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2021-01-04 23:00:00 │
└───────────────────────────────────────────────────────────┘
别名：TO_TIMESTAMP。
parseDateTimeOrZero
与 parseDateTime 相同，只是在遇到无法处理的日期格式时返回零日期。
parseDateTimeOrNull
与 parseDateTime 相同，只是在遇到无法处理的日期格式时返回 NULL。
别名：str_to_date。
parseDateTimeInJodaSyntax
类似于 parseDateTime，只是格式字符串使用的是 Joda 语法而不是 MySQL 语法。
此函数是函数 formatDateTimeInJodaSyntax 的反向操作。
语法
parseDateTimeInJodaSyntax(str[, format[, timezone]])
参数
str— 要解析的字符串format— 格式字符串。可选。如果未指定，则为yyyy-MM-dd HH:mm:ss。timezone— 时区。可选。
返回值
根据 Joda 样式格式从输入字符串解析的 DateTime 值。
支持的格式说明符
支持 formatDateTimeInJoda 中列出的所有格式说明符，除了
- S: 秒的小数部分
- z: 时区
- Z: 时区偏移量/ID
示例
SELECT parseDateTimeInJodaSyntax('2023-02-24 14:53:31', 'yyyy-MM-dd HH:mm:ss', 'Europe/Minsk')
┌─parseDateTimeInJodaSyntax('2023-02-24 14:53:31', 'yyyy-MM-dd HH:mm:ss', 'Europe/Minsk')─┐
│ 2023-02-24 14:53:31 │
└─────────────────────────────────────────────────────────────────────────────────────────┘
parseDateTimeInJodaSyntaxOrZero
与 parseDateTimeInJodaSyntax 相同，只是在遇到无法处理的日期格式时返回零日期。
parseDateTimeInJodaSyntaxOrNull
与 parseDateTimeInJodaSyntax 相同，只是在遇到无法处理的日期格式时返回 NULL。
parseDateTimeBestEffort
parseDateTime32BestEffort
将 String 表示形式的日期和时间转换为 DateTime 数据类型。
该函数解析 ISO 8601、RFC 1123 - 5.2.14 RFC-822 日期和时间规范、ClickHouse 和其他一些日期和时间格式。
语法
parseDateTimeBestEffort(time_string [, time_zone])
参数
支持的非标准格式
- 包含 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等。例如，2020-12-12 17:36:00 -5:00。 - 一个 syslog 时间戳：
Mmm dd hh:mm:ss。例如，Jun 9 14:20:32。
对于所有使用分隔符的格式，该函数解析由其全称或月份名称的前三个字母表示的月份名称。示例：24/DEC/18、24-Dec-18、01-September-2018。如果未指定年份，则将其视为当前年份。如果得到的 DateTime 恰好是未来（甚至比当前时刻晚一秒），则当前年份将替换为前一年。
返回值
time_string转换为 DateTime 数据类型。
示例
查询
SELECT parseDateTimeBestEffort('23/10/2020 12:12:57')
AS parseDateTimeBestEffort;
结果
┌─parseDateTimeBestEffort─┐
│ 2020-10-23 12:12:57 │
└─────────────────────────┘
查询
SELECT parseDateTimeBestEffort('Sat, 18 Aug 2018 07:22:16 GMT', 'Asia/Istanbul')
AS parseDateTimeBestEffort;
结果
┌─parseDateTimeBestEffort─┐
│ 2018-08-18 10:22:16 │
└─────────────────────────┘
查询
SELECT parseDateTimeBestEffort('1284101485')
AS parseDateTimeBestEffort;
结果
┌─parseDateTimeBestEffort─┐
│ 2015-07-07 12:04:41 │
└─────────────────────────┘
查询
SELECT parseDateTimeBestEffort('2018-10-23 10:12:12')
AS parseDateTimeBestEffort;
结果
┌─parseDateTimeBestEffort─┐
│ 2018-10-23 10:12:12 │
└─────────────────────────┘
查询
SELECT toYear(now()) as year, parseDateTimeBestEffort('10 20:19');
结果
┌─year─┬─parseDateTimeBestEffort('10 20:19')─┐
│ 2023 │ 2023-01-10 20:19:00 │
└──────┴─────────────────────────────────────┘
查询
WITH
now() AS ts_now,
formatDateTime(ts_around, '%b %e %T') AS syslog_arg
SELECT
ts_now,
syslog_arg,
parseDateTimeBestEffort(syslog_arg)
FROM (SELECT arrayJoin([ts_now - 30, ts_now + 30]) AS ts_around);
结果
┌──────────────ts_now─┬─syslog_arg──────┬─parseDateTimeBestEffort(syslog_arg)─┐
│ 2023-06-30 23:59:30 │ Jun 30 23:59:00 │ 2023-06-30 23:59:00 │
│ 2023-06-30 23:59:30 │ Jul 1 00:00:00 │ 2022-07-01 00:00:00 │
└─────────────────────┴─────────────────┴─────────────────────────────────────┘
另请参阅
parseDateTimeBestEffortUS
对于 ISO 日期格式（例如 YYYY-MM-DD hh:mm:ss）和其他可以明确提取月份和日期组件的日期格式（例如 YYYYMMDDhhmmss、YYYY-MM、DD hh 或 YYYY-MM-DD hh:mm:ss ±h:mm），此函数的行为类似于 parseDateTimeBestEffort。如果无法明确提取月份和日期组件（例如 MM/DD/YYYY、MM-DD-YYYY 或 MM-DD-YY），则它优先选择 US 日期格式而不是 DD/MM/YYYY、DD-MM-YYYY 或 DD-MM-YY。作为后者的例外情况，如果月份大于 12 且小于或等于 31，则此函数将回退到 parseDateTimeBestEffort 的行为，例如 15/08/2020 将解析为 2020-08-15。
parseDateTimeBestEffortOrNull
parseDateTime32BestEffortOrNull
与 parseDateTimeBestEffort 相同，只是在遇到无法处理的日期格式时返回 NULL。
parseDateTimeBestEffortOrZero
parseDateTime32BestEffortOrZero
与 parseDateTimeBestEffort 相同，只是在遇到无法处理的日期格式时返回零日期或零日期时间。
parseDateTimeBestEffortUSOrNull
与 parseDateTimeBestEffortUS 函数相同，只是在遇到无法处理的日期格式时返回 NULL。
parseDateTimeBestEffortUSOrZero
与 parseDateTimeBestEffortUS 函数相同，只是在遇到无法处理的日期格式时返回零日期 (1970-01-01) 或零日期时间 (1970-01-01 00:00:00)。
parseDateTime64BestEffort
与 parseDateTimeBestEffort 函数相同，但也会解析毫秒和微秒，并返回 DateTime 数据类型。
语法
parseDateTime64BestEffort(time_string [, precision [, time_zone]])
参数
time_string— 包含要转换的日期或日期时间的字符串。 String。precision— 需要的精度。3— 毫秒，6— 微秒。默认 —3。可选。 UInt8。time_zone— 时区。该函数根据时区解析time_string。可选。 String。
返回值
time_string转换为 DateTime 数据类型。
示例
查询
SELECT parseDateTime64BestEffort('2021-01-01') AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2021-01-01 01:01:00.12346') AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2021-01-01 01:01:00.12346',6) AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2021-01-01 01:01:00.12346',3,'Asia/Istanbul') AS a, toTypeName(a) AS t
FORMAT PrettyCompactMonoBlock;
结果
┌──────────────────────────a─┬─t──────────────────────────────┐
│ 2021-01-01 01:01:00.123000 │ DateTime64(3) │
│ 2021-01-01 00:00:00.000000 │ DateTime64(3) │
│ 2021-01-01 01:01:00.123460 │ DateTime64(6) │
│ 2020-12-31 22:01:00.123000 │ DateTime64(3, 'Asia/Istanbul') │
└────────────────────────────┴────────────────────────────────┘
parseDateTime64BestEffortUS
与 parseDateTime64BestEffort 相同，只是此函数在出现歧义时优先选择 US 日期格式 (MM/DD/YYYY 等)。
parseDateTime64BestEffortOrNull
与 parseDateTime64BestEffort 相同，只是在遇到无法处理的日期格式时返回 NULL。
parseDateTime64BestEffortOrZero
与 parseDateTime64BestEffort 相同，只是在遇到无法处理的日期格式时返回零日期或零日期时间。
parseDateTime64BestEffortUSOrNull
与parseDateTime64BestEffort相同，除了此函数在出现歧义时优先使用美国日期格式（MM/DD/YYYY 等），并在遇到无法处理的日期格式时返回NULL。
parseDateTime64BestEffortUSOrZero
与parseDateTime64BestEffort相同，除了此函数在出现歧义时优先使用美国日期格式（MM/DD/YYYY 等），并在遇到无法处理的日期格式时返回零日期或零日期时间。
toLowCardinality
将输入参数转换为相同数据类型的LowCardinality版本。
要从LowCardinality数据类型转换数据，请使用CAST函数。例如，CAST(x as String)。
语法
toLowCardinality(expr)
参数
返回值
expr的结果。LowCardinality，类型为expr。
示例
查询
SELECT toLowCardinality('1');
结果
┌─toLowCardinality('1')─┐
│ 1 │
└───────────────────────┘
toUnixTimestamp64Milli
将DateTime64转换为具有固定毫秒精度的Int64值。输入值会根据其精度进行适当的放大或缩小。
输出值为UTC时间戳，而不是DateTime64的时区。
语法
toUnixTimestamp64Milli(value)
参数
value— 具有任意精度的DateTime64值。DateTime64。
返回值
value转换为Int64数据类型。Int64。
示例
查询
WITH toDateTime64('2009-02-13 23:31:31.011', 3, 'UTC') AS dt64
SELECT toUnixTimestamp64Milli(dt64);
结果
┌─toUnixTimestamp64Milli(dt64)─┐
│ 1234567891011 │
└──────────────────────────────┘
toUnixTimestamp64Micro
将DateTime64转换为具有固定微秒精度的Int64值。输入值会根据其精度进行适当的放大或缩小。
输出值为UTC时间戳，而不是DateTime64的时区。
语法
toUnixTimestamp64Micro(value)
参数
value— 具有任意精度的DateTime64值。DateTime64。
返回值
value转换为Int64数据类型。Int64。
示例
查询
WITH toDateTime64('1970-01-15 06:56:07.891011', 6, 'UTC') AS dt64
SELECT toUnixTimestamp64Micro(dt64);
结果
┌─toUnixTimestamp64Micro(dt64)─┐
│ 1234567891011 │
└──────────────────────────────┘
toUnixTimestamp64Nano
将DateTime64转换为具有固定纳秒精度的Int64值。输入值会根据其精度进行适当的放大或缩小。
输出值为UTC时间戳，而不是DateTime64的时区。
语法
toUnixTimestamp64Nano(value)
参数
value— 具有任意精度的DateTime64值。DateTime64。
返回值
value转换为Int64数据类型。Int64。
示例
查询
WITH toDateTime64('1970-01-01 00:20:34.567891011', 9, 'UTC') AS dt64
SELECT toUnixTimestamp64Nano(dt64);
结果
┌─toUnixTimestamp64Nano(dt64)─┐
│ 1234567891011 │
└─────────────────────────────┘
fromUnixTimestamp64Milli
将Int64转换为具有固定毫秒精度和可选时区的DateTime64值。输入值会根据其精度进行适当的放大或缩小。
请注意，输入值被视为UTC时间戳，而不是给定（或隐式）时区的时间戳。
语法
fromUnixTimestamp64Milli(value[, timezone])
参数
返回值
value转换为精度为3的DateTime64。DateTime64。
示例
查询
WITH CAST(1234567891011, 'Int64') AS i64
SELECT
fromUnixTimestamp64Milli(i64, 'UTC') AS x,
toTypeName(x);
结果
┌───────────────────────x─┬─toTypeName(x)────────┐
│ 2009-02-13 23:31:31.011 │ DateTime64(3, 'UTC') │
└─────────────────────────┴──────────────────────┘
fromUnixTimestamp64Micro
将Int64转换为具有固定微秒精度和可选时区的DateTime64值。输入值会根据其精度进行适当的放大或缩小。
请注意，输入值被视为UTC时间戳，而不是给定（或隐式）时区的时间戳。
语法
fromUnixTimestamp64Micro(value[, timezone])
参数
返回值
value转换为精度为6的DateTime64。DateTime64。
示例
查询
WITH CAST(1234567891011, 'Int64') AS i64
SELECT
fromUnixTimestamp64Micro(i64, 'UTC') AS x,
toTypeName(x);
结果
┌──────────────────────────x─┬─toTypeName(x)────────┐
│ 1970-01-15 06:56:07.891011 │ DateTime64(6, 'UTC') │
└────────────────────────────┴──────────────────────┘
fromUnixTimestamp64Nano
将Int64转换为具有固定纳秒精度和可选时区的DateTime64值。输入值会根据其精度进行适当的放大或缩小。
请注意，输入值被视为UTC时间戳，而不是给定（或隐式）时区的时间戳。
语法
fromUnixTimestamp64Nano(value[, timezone])
参数
返回值
value转换为精度为9的DateTime64。DateTime64。
示例
查询
WITH CAST(1234567891011, 'Int64') AS i64
SELECT
fromUnixTimestamp64Nano(i64, 'UTC') AS x,
toTypeName(x);
结果
┌─────────────────────────────x─┬─toTypeName(x)────────┐
│ 1970-01-01 00:20:34.567891011 │ DateTime64(9, 'UTC') │
└───────────────────────────────┴──────────────────────┘
formatRow
通过给定的格式将任意表达式转换为字符串。
语法
formatRow(format, x, y, ...)
参数
返回值
- 格式化的字符串。（对于文本格式，通常以换行符结尾）。
示例
查询
SELECT formatRow('CSV', number, 'good')
FROM numbers(3);
结果
┌─formatRow('CSV', number, 'good')─┐
│ 0,"good"
│
│ 1,"good"
│
│ 2,"good"
│
└──────────────────────────────────┘
注意：如果格式包含后缀/前缀，它将写入每一行。
示例
查询
SELECT formatRow('CustomSeparated', number, 'good')
FROM numbers(3)
SETTINGS format_custom_result_before_delimiter='<prefix>\n', format_custom_result_after_delimiter='<suffix>'
结果
┌─formatRow('CustomSeparated', number, 'good')─┐
│ <prefix>
0 good
<suffix> │
│ <prefix>
1 good
<suffix> │
│ <prefix>
2 good
<suffix> │
└──────────────────────────────────────────────┘
注意：此函数仅支持基于行的格式。
formatRowNoNewline
通过给定的格式将任意表达式转换为字符串。与formatRow不同的是，此函数会修剪最后一个\n（如果有）。
语法
formatRowNoNewline(format, x, y, ...)
参数
返回值
- 格式化的字符串。
示例
查询
SELECT formatRowNoNewline('CSV', number, 'good')
FROM numbers(3);
结果
┌─formatRowNoNewline('CSV', number, 'good')─┐
│ 0,"good" │
│ 1,"good" │
│ 2,"good" │
└───────────────────────────────────────────┘