类型转换函数
数据转换的常见问题
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
另请参阅
toBFloat16
将输入值转换为 BFloat16 类型的值。如果发生错误，则抛出异常。
语法
toBFloat16(expr)
参数
expr— 返回数字或数字字符串表示形式的表达式。表达式。
支持的参数
- (U)Int8/16/32/64/128/256 类型的值。
- (U)Int8/16/32/128/256 的字符串表示形式。
- Float32/64 类型的值，包括
NaN和Inf。 - Float32/64 的字符串表示形式，包括
NaN和Inf(不区分大小写)。
返回值
- 16 位 brain-float 值。BFloat16。
示例
SELECT toBFloat16(toFloat32(42.7))
42.5
SELECT toBFloat16(toFloat32('42.7'));
42.5
SELECT toBFloat16('42.7');
42.5
另请参阅
toBFloat16OrZero
将字符串输入值转换为 BFloat16 类型的值。如果字符串不表示浮点数值，则该函数返回零。
语法
toBFloat16OrZero(x)
参数
x— 数字的字符串表示形式。String。
支持的参数
- 数值的字符串表示形式。
不支持的参数（返回 0）
- 二进制和十六进制值的字符串表示形式。
- 数值。
返回值
- 如果成功，则返回 16 位 brain-float 值，否则返回
0。BFloat16。
该函数允许在从字符串表示形式转换时静默丢失精度。
示例
SELECT toBFloat16OrZero('0x5E'); -- unsupported arguments
0
SELECT toBFloat16OrZero('12.3'); -- typical use
12.25
SELECT toBFloat16OrZero('12.3456789');
12.3125 -- silent loss of precision
另请参阅
toBFloat16OrNull
将字符串输入值转换为 BFloat16 类型的值，但如果字符串不表示浮点数值，则该函数返回 NULL。
语法
toBFloat16OrNull(x)
参数
x— 数字的字符串表示形式。String。
支持的参数
- 数值的字符串表示形式。
不支持的参数 (返回 NULL)
- 二进制和十六进制值的字符串表示形式。
- 数值。
返回值
- 如果成功，则返回 16 位 brain-float 值，否则返回
NULL(\N)。BFloat16。
该函数允许在从字符串表示形式转换时静默丢失精度。
示例
SELECT toBFloat16OrNull('0x5E'); -- unsupported arguments
\N
SELECT toBFloat16OrNull('12.3'); -- typical use
12.25
SELECT toBFloat16OrNull('12.3456789');
12.3125 -- silent loss of precision
另请参阅
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-精度 秒。有效范围：[ 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-精度 秒。有效范围：[ 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-精度 秒。有效范围：[ 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-精度 秒。有效范围：[ 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。您可以使用 String 输入，以便操作使用底层整数类型：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)
参数
返回值
- 重新解释为 UInt8 的值
x。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)
参数
返回值
- 重新解释为 UInt16 的值
x。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)
参数
返回值
- 重新解释为 UInt32 的值
x。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)
参数
返回值
- 重新解释为 UInt64 的值
x。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)
参数
返回值
- 重新解释为 UInt128 的值
x。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)
参数
返回值
- 重新解释为 UInt256 的值
x。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)
参数
返回值
- 重新解释为 Int8 的值
x。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)
参数
返回值
- 重新解释为 Int16 的值
x。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)
参数
返回值
- 重新解释为 Int32 的值
x。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)
参数
返回值
- 重新解释为 Int64 的值
x。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)
参数
返回值
- 重新解释为 Int128 的值
x。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)
参数
返回值
- 重新解释为 Int256 的值
x。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)
参数
返回值
- 重新解释为 Float32 的值
x。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 的字符串是一个字节长。
语法
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 是一个字节长。
语法
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 │
└─────────────────────┴─────────────────────┴────────────┴─────────────────────┴───────────────────────────┘
转换为 FixedString (N) 仅适用于 String 或 FixedString 类型的参数。
支持转换为 Nullable 类型以及从 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
返回数据类型为 IntervalYear 的 n 年间隔。
语法
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
返回数据类型为 IntervalQuarter 的 n 季度间隔。
语法
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
返回数据类型为 IntervalMonth 的 n 月间隔。
语法
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
返回数据类型为 IntervalWeek 的 n 周间隔。
语法
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
返回数据类型为 IntervalDay 的 n 天间隔。
语法
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
返回数据类型为 IntervalHour 的 n 小时间隔。
语法
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
返回数据类型为 IntervalMinute 的 n 分钟间隔。
语法
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
返回数据类型为 IntervalSecond 的 n 秒间隔。
语法
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
返回数据类型为 IntervalMillisecond 的 n 毫秒间隔。
语法
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
返回数据类型为 IntervalMicrosecond 的 n 微秒间隔。
语法
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
返回数据类型为 IntervalNanosecond 的 n 纳秒间隔。
语法
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。
parseDateTime64
根据 MySQL 格式字符串 将 String 转换为 DateTime64。
语法
parseDateTime64(str[, format[, timezone]])
参数
str— 要解析的字符串。format— 格式字符串。可选。如果未指定，则为%Y-%m-%d %H:%i:%s.%f。timezone— 时区。可选。
返回值
返回根据 MySQL 样式格式字符串从输入字符串解析的 DateTime64 值。返回值的精度为 6。
parseDateTime64OrZero
与 parseDateTime64 相同，不同之处在于，当遇到无法处理的日期格式时，它会返回零日期。
parseDateTime64OrNull
与 parseDateTime64 相同，不同之处在于，当遇到无法处理的日期格式时，它会返回 NULL。
parseDateTime64InJodaSyntax
根据 Joda 格式字符串 将 String 转换为 DateTime64。
语法
parseDateTime64InJodaSyntax(str[, format[, timezone]])
参数
str— 要解析的字符串。format— 格式字符串。可选。如果未指定，则为yyyy-MM-dd HH:mm:ss。timezone— 时区。可选。
返回值
返回根据 Joda 样式格式字符串从输入字符串解析的 DateTime64 值。返回值的精度等于格式字符串中 S 占位符的数量（但最多为 6）。
parseDateTime64InJodaSyntaxOrZero
与 parseDateTime64InJodaSyntax 相同，不同之处在于，当遇到无法处理的日期格式时，它会返回零日期。
parseDateTime64InJodaSyntaxOrNull
与 parseDateTime64InJodaSyntax 相同，不同之处在于，当遇到无法处理的日期格式时，它会返回 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），则它优先使用美国日期格式，而不是 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 相同，不同之处在于，如果存在歧义，此函数优先使用美国日期格式 (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的结果。expr类型的 LowCardinality。
示例
查询
SELECT toLowCardinality('1');
结果
┌─toLowCardinality('1')─┐
│ 1 │
└───────────────────────┘
toUnixTimestamp64Second
将 DateTime64 转换为具有固定秒精度的 Int64 值。输入值会根据其精度进行适当的放大或缩小。
输出值是 UTC 时间戳，而不是 DateTime64 的时区。
语法
toUnixTimestamp64Second(value)
参数
value— 具有任何精度的 DateTime64 值。 DateTime64。
返回值
value转换为Int64数据类型。 Int64。
示例
查询
WITH toDateTime64('2009-02-13 23:31:31.011', 3, 'UTC') AS dt64
SELECT toUnixTimestamp64Second(dt64);
结果
┌─toUnixTimestamp64Second(dt64)─┐
│ 1234567891 │
└───────────────────────────────┘
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 │
└─────────────────────────────┘
fromUnixTimestamp64Second
将 Int64 转换为具有固定秒精度和可选时区的 DateTime64 值。输入值会根据其精度进行适当的放大或缩小。
请注意，输入值被视为 UTC 时间戳，而不是给定（或隐式）时区的时间戳。
语法
fromUnixTimestamp64Second(value[, timezone])
参数
返回值
value转换为精度为0的 DateTime64。 DateTime64。
示例
查询
WITH CAST(1733935988, 'Int64') AS i64
SELECT
fromUnixTimestamp64Second(i64, 'UTC') AS x,
toTypeName(x);
结果
┌───────────────────x─┬─toTypeName(x)────────┐
│ 2024-12-11 16:53:08 │ DateTime64(0, 'UTC') │
└─────────────────────┴──────────────────────┘
fromUnixTimestamp64Milli
将 Int64 转换为具有固定毫秒精度和可选时区的 DateTime64 值。输入值会根据其精度进行适当的向上或向下调整。
请注意，输入值被视为 UTC 时间戳，而不是给定（或隐式）时区的时间戳。
语法
fromUnixTimestamp64Milli(value[, timezone])
参数
返回值
value转换为精度为3的 DateTime64。 DateTime64。
示例
查询
WITH CAST(1733935988123, 'Int64') AS i64
SELECT
fromUnixTimestamp64Milli(i64, 'UTC') AS x,
toTypeName(x);
结果
┌───────────────────────x─┬─toTypeName(x)────────┐
│ 2024-12-11 16:53:08.123 │ DateTime64(3, 'UTC') │
└─────────────────────────┴──────────────────────┘
fromUnixTimestamp64Micro
将 Int64 转换为具有固定微秒精度和可选时区的 DateTime64 值。输入值会根据其精度进行适当的向上或向下调整。
请注意，输入值被视为 UTC 时间戳，而不是给定（或隐式）时区的时间戳。
语法
fromUnixTimestamp64Micro(value[, timezone])
参数
返回值
value转换为精度为6的 DateTime64。 DateTime64。
示例
查询
WITH CAST(1733935988123456, 'Int64') AS i64
SELECT
fromUnixTimestamp64Micro(i64, 'UTC') AS x,
toTypeName(x);
结果
┌──────────────────────────x─┬─toTypeName(x)────────┐
│ 2024-12-11 16:53:08.123456 │ DateTime64(6, 'UTC') │
└────────────────────────────┴──────────────────────┘
fromUnixTimestamp64Nano
将 Int64 转换为具有固定纳秒精度和可选时区的 DateTime64 值。输入值会根据其精度进行适当的向上或向下调整。
请注意，输入值被视为 UTC 时间戳，而不是给定（或隐式）时区的时间戳。
语法
fromUnixTimestamp64Nano(value[, timezone])
参数
返回值
value转换为精度为9的 DateTime64。 DateTime64。
示例
查询
WITH CAST(1733935988123456789, 'Int64') AS i64
SELECT
fromUnixTimestamp64Nano(i64, 'UTC') AS x,
toTypeName(x);
结果
┌─────────────────────────────x─┬─toTypeName(x)────────┐
│ 2024-12-11 16:53:08.123456789 │ 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" │
└───────────────────────────────────────────┘