二十九、clickhouse其他函数
作者：互联网
hostName
返回一个字符串，其中包含执行此函数的主机的名称。对于分布式处理，这是远程服务器主机的名称，如果该功能是在远程服务器上执行的。如果它在分布式表的上下文中执行，那么它会生成一个普通列，其中包含与每个分片相关的值。否则它会产生一个常数值。
SELECT hostName() Query id: f377fe1b-9976-468d-97eb-8674fb3ba95d ┌─hostName()─┐ │ data │ └────────────┘
getMacro
从服务器配置的宏部分获取命名值。
句法
getMacro(name);
论据
name— 要从该macros部分检索的名称。字符串。
返回值
- 指定宏的值。
类型：字符串。
例子
macros服务器配置文件中的示例部分：
<macros>
<test>Value</test>
</macros>
SELECT getMacro('test');
┌─getMacro('test')─┐
│ Value │
└──────────────────┘
--获得相同值的另一种方法：
SELECT * FROM system.macros
WHERE macro = 'test';
┌─macro─┬─substitution─┐
│ test │ Value │
└───────┴──────────────┘
FQDN
返回完全限定的域名。
句法
fqdn();
此函数不区分大小写。
返回值
- 具有完全限定域名的字符串。
类型：String.
例子
SELECT FQDN() Query id: 94fc212c-9fb5-4dd9-a901-0b3e939d5c1f ┌─FQDN()─┐ │ data │ └────────┘
basename
在最后一个斜杠或反斜杠之后提取字符串的尾部。此函数经常用于从路径中提取文件名。
basename( expr )
论据
expr— 产生字符串类型值的表达式。所有反斜杠必须在结果值中转义。
返回值
包含以下内容的字符串：
-
最后一个斜杠或反斜杠之后的字符串尾随部分。
如果输入字符串包含以斜杠或反斜杠结尾的路径，例如 `/` 或 `c:\`，则该函数返回一个空字符串。 -
如果没有斜杠或反斜杠，则为原始字符串。
例子
SELECT
'some/long/path/to/file' AS a,
basename(a)
Query id: 4ea13b56-3b0d-403e-90af-24533f79549e
┌─a──────────────────────┬─basename('some/long/path/to/file')─┐
│ some/long/path/to/file │ file │
└────────────────────────┴────────────────────────────────────┘
SELECT
'some\\long\\path\\to\\file' AS a,
basename(a)
Query id: 69a3cb2a-b89f-4dc5-a00e-af2d77477142
┌─a──────────────────────┬─basename('some\\long\\path\\to\\file')─┐
│ some\long\path\to\file │ file │
└────────────────────────┴────────────────────────────────────────┘
SELECT
'some-file-name' AS a,
basename(a)
Query id: e1ca2116-3819-4c4a-af22-763855ae85bb
┌─a──────────────┬─basename('some-file-name')─┐
│ some-file-name │ some-file-name │
└────────────────┴────────────────────────────┘
visibleWidth(x )
以文本格式（制表符分隔）将值输出到控制台时计算近似宽度。系统使用此函数来实现 Pretty 格式。
NULL表示为对应NULL于Pretty格式的字符串。
SELECT visibleWidth(NULL) Query id: 73dd882d-bb43-4659-b9b8-f2f320264c40 ┌─visibleWidth(NULL)─┐ │ 4 │ └────────────────────┘
toTypeName(x )
返回包含传递参数的类型名称的字符串。
如果NULL作为输入传递给函数，则返回类型，该类型对应于 ClickHouseNullable(Nothing)中的内部表示。--NULL
SELECT toTypeName(11) Query id: 74a8e4f6-0ed9-41fb-aa1c-ae442cb27179 ┌─toTypeName(11)─┐ │ UInt8 │ └────────────────┘
blockSize( )
获取块的大小。在 ClickHouse 中，查询总是在块（列部分集）上运行。此函数允许获取调用它的块的大小。
select blockSize() from isv_data_prod.dm_order;
│ 45142 │
│ 45142 │
└─────────────┘
Showed first 10000.
byteSize
返回对其参数在内存中的未压缩字节大小的估计。
句法
byteSize(argument [, ...])
论据
argument- 值。
返回值
- 估计内存中参数的字节大小。
类型：UInt64。
例子
对于字符串参数，该函数返回字符串长度 + 9（终止零 + 长度）。
SELECT byteSize('string')
Query id: ed69ba43-3a92-461c-a238-b0ca0100fab6
┌─byteSize('string')─┐
│ 15 │
└────────────────────┘
CREATE TABLE test
(
`key` Int32,
`u8` UInt8,
`u16` UInt16,
`u32` UInt32,
`u64` UInt64,
`i8` Int8,
`i16` Int16,
`i32` Int32,
`i64` Int64,
`f32` Float32,
`f64` Float64
)
ENGINE = MergeTree
ORDER BY key
INSERT INTO test VALUES(1, 8, 16, 32, 64, -8, -16, -32, -64, 32.32, 64.64);
SELECT
key,
byteSize(u8) AS `byteSize(UInt8)`,
byteSize(u16) AS `byteSize(UInt16)`,
byteSize(u32) AS `byteSize(UInt32)`,
byteSize(u64) AS `byteSize(UInt64)`,
byteSize(i8) AS `byteSize(Int8)`,
byteSize(i16) AS `byteSize(Int16)`,
byteSize(i32) AS `byteSize(Int32)`,
byteSize(i64) AS `byteSize(Int64)`,
byteSize(f32) AS `byteSize(Float32)`,
byteSize(f64) AS `byteSize(Float64)`
FROM test
ORDER BY key ASC
FORMAT Vertical
Query id: 0d35afd8-0caf-4c22-9214-b859c426786a
Row 1:
──────
key: 1
byteSize(UInt8): 1
byteSize(UInt16): 2
byteSize(UInt32): 4
byteSize(UInt64): 8
byteSize(Int8): 1
byteSize(Int16): 2
byteSize(Int32): 4
byteSize(Int64): 8
byteSize(Float32): 4
byteSize(Float64): 8
如果函数接受多个参数，则返回它们的组合字节大小。
SELECT byteSize(NULL, 1, 0.3, '') Query id: db239870-0f30-47c9-8e18-fc88cd9150f0 ┌─byteSize(NULL, 1, 0.3, '')─┐ │ 19 │ └────────────────────────────┘
materialize(x)
将常量转换为仅包含一个值的完整列。在 ClickHouse 中，完整的列和常量在内存中的表示方式不同。函数对常量参数和普通参数的工作方式不同（执行不同的代码），尽管结果几乎总是相同的。此函数用于调试此行为。
SELECT materialize('14444')
Query id: 67d61cd3-b024-4207-8f63-dc834a64cf0d
┌─materialize('14444')─┐
│ 14444 │
└──────────────────────┘
SELECT materialize(city)
FROM agg_table_basic
Query id: 99c64b8f-32fd-4d42-87dc-59add896925f
┌─materialize(city)─┐
│ wuhan │
│ wuhan │
└───────────────────┘
┌─materialize(city)─┐
│ zhuhai │
└───────────────────┘
ignore(…)
接受任何参数，包括NULL. 始终返回 0。但是，仍会评估参数。这可用于基准测试。
SELECT ignore(NULL) Query id: 22d03120-bf9e-4d68-9810-ea34750a2e00 ┌─ignore(NULL)─┐ │ 0 │ └──────────────┘
sleep(seconds)
在每个数据块上休眠“秒”秒。可以指定整数或浮点数。
SELECT sleep(2) Query id: e2157b31-a50b-4aef-90e5-2f51ba48c267 ┌─sleep(2)─┐ │ 0 │ └──────────┘
sleepEachRow(seconds)
在每一行上休眠“秒”秒。可以指定整数或浮点数。
SELECT sleepEachRow(2) Query id: 14804205-cf15-4cc9-a080-8576377693ba ┌─sleepEachRow(2)─┐ │ 0 │ └─────────────────┘
currentDatabase()
返回当前数据库的名称。可以在需要指定数据库的 CREATE TABLE 查询中的表引擎参数中使用此函数。
SELECT currentDatabase() Query id: 07d56e84-6d5c-44e7-a49d-c7014859598d ┌─currentDatabase()─┐ │ test │ └───────────────────┘
currentUser()
返回当前用户的登录信息。如果是分布式查询，将返回发起查询的用户登录名。
SELECT currentUser();
别名：user(), USER().
返回值
- 当前用户的登录。
- 在分布式查询的情况下发起查询的用户的登录。
类型：String.
例子
SELECT currentUser() Query id: 7a0d6ca7-b736-473a-b33d-e03e507b3c1f ┌─currentUser()─┐ │ default │ └───────────────┘
isConstant
检查参数是否为常量表达式。
常量表达式表示其结果值在查询分析时（即执行之前）已知的表达式。例如，文字上的表达式是常量表达式。
该函数用于开发、调试和演示。
句法
isConstant(x)
论据
x— 要检查的表达式。
返回值
1—x是恒定的。0—x是非常量的。
类型：UInt8。
例子
SELECT isConstant(x + 1)
FROM
(
SELECT 43 AS x
)
Query id: 18559416-55d6-4243-a7a6-af481978be92
┌─isConstant(plus(x, 1))─┐
│ 1 │
└────────────────────────┘
WITH 3.14 AS pi
SELECT isConstant(cos(pi))
Query id: 167b7125-7a9d-48e9-8a4f-604e1c3ed621
┌─isConstant(cos(pi))─┐
│ 1 │
└─────────────────────┘
SELECT isConstant(number)
FROM numbers(1)
Query id: 40d9b588-2e46-405f-a088-b8665872adb4
┌─isConstant(number)─┐
│ 0 │
└────────────────────┘
isFinite(x)
接受 Float32 和 Float64，如果参数不是无限大且不是 NaN，则返回 UInt8 等于 1，否则返回 0。
SELECT isFinite(4.555) Query id: 708403db-c67d-426d-8432-a3b4eaafedd8 ┌─isFinite(4.555)─┐ │ 1 │ └─────────────────┘
isInfinite(x)
接受 Float32 和 Float64，如果参数是无限的，则返回 UInt8 等于 1，否则返回 0。请注意，对于 NaN，返回 0。
SELECT isInfinite(sqrt(25)) Query id: 32bf861b-8b5a-4e71-b3dd-c5f6abefb5b2 ┌─isInfinite(sqrt(25))─┐ │ 0 │ └──────────────────────┘
ifNotFinite
检查浮点值是否是有限的。
句法
ifNotFinite(x,y)
论据
x— 要检查无穷大的值。类型：浮点*。y— 后备值。类型：浮点*。
返回值
x如果x是有限的。yifx不是有限的。
例子
SELECT
1 / 0 AS infimum,
ifNotFinite(infimum, 42)
Query id: 1b0e223d-05b8-4f2b-8b0b-3d8a54260306
┌─infimum─┬─ifNotFinite(divide(1, 0), 42)─┐
│ inf │ 42 │
└─────────┴───────────────────────────────┘
可以使用三元运算符:获得类似的结果isFinite(x) ? x : y。
isNaN (x )
接受 Float32 和 Float64，如果参数是 NaN，则返回 UInt8 等于 1，否则返回 0。
SELECT isNaN(nan) Query id: 396ffce1-8033-43ef-a925-c5be7f050475 ┌─isNaN(nan)─┐ │ 1 │ └────────────┘
hasColumnInTable([‘hostname’[, ‘username’[, ‘password’]],] ‘database’, ‘table’, ‘column’)
接受常量字符串：数据库名称、表名称和列名称。如果有列，则返回等于 1 的 UInt8 常量表达式，否则返回 0。如果设置了 hostname 参数，则测试将在远程服务器上运行。如果表不存在，该函数将引发异常。对于嵌套数据结构中的元素，该函数检查是否存在列。对于嵌套数据结构本身，该函数返回 0。
SELECT hasColumnInTable('test', 'agg_table_basic', 'city')
Query id: 9d22f390-b987-4f31-a11a-75d8d04c05fb
┌─hasColumnInTable('test', 'agg_table_basic', 'city')─┐
│ 1 │
└─────────────────────────────────────────────────────┘
bar
允许构建 unicode-art 图表。
bar(x, min, max, width)(x - min)在. _ width_x = max
论据
x— 要显示的大小。min, max— 整数常量。该值必须适合Int64。width— 常数，正整数，可以是小数。
带的绘制精确到符号的八分之一。
例子：
SELECT
toHour(EventTime) AS h,
count() AS c,
bar(c, 0, 600000, 20) AS bar
FROM test.hits
GROUP BY h
ORDER BY h ASC
┌──h─┬──────c─┬─bar────────────────┐
│ 0 │ 292907 │ █████████▋ │
│ 1 │ 180563 │ ██████ │
│ 2 │ 114861 │ ███▋ │
│ 3 │ 85069 │ ██▋ │
│ 4 │ 68543 │ ██▎ │
│ 5 │ 78116 │ ██▌ │
│ 6 │ 113474 │ ███▋ │
│ 7 │ 170678 │ █████▋ │
│ 8 │ 278380 │ █████████▎ │
│ 9 │ 391053 │ █████████████ │
│ 10 │ 457681 │ ███████████████▎ │
│ 11 │ 493667 │ ████████████████▍ │
│ 12 │ 509641 │ ████████████████▊ │
│ 13 │ 522947 │ █████████████████▍ │
│ 14 │ 539954 │ █████████████████▊ │
│ 15 │ 528460 │ █████████████████▌ │
│ 16 │ 539201 │ █████████████████▊ │
│ 17 │ 523539 │ █████████████████▍ │
│ 18 │ 506467 │ ████████████████▊ │
│ 19 │ 520915 │ █████████████████▎ │
│ 20 │ 521665 │ █████████████████▍ │
│ 21 │ 542078 │ ██████████████████ │
│ 22 │ 493642 │ ████████████████▍ │
│ 23 │ 400397 │ █████████████▎ │
└────┴────────┴────────────────────┘
transform
根据某些元素到其他元素的明确定义的映射转换一个值。此功能有两种变体：
transform(x, array_from, array_to, default)
x– 改造什么。
array_from– 用于转换的常量数组。
array_to– 常量数组，用于将 'from' 中的值转换为。
default– 如果“x”不等于“from”中的任何值，则使用哪个值。
array_from和array_to– 相同大小的数组。
类型：
transform(T, Array(T), Array(U), U) -> U
T并且U可以是数字、字符串或日期或日期时间类型。在指示相同字母（T 或 U）的情况下，对于数字类型，这些可能不是匹配类型，而是具有通用类型的类型。例如，第一个参数可以是 Int64 类型，而第二个参数可以是 Array(UInt16) 类型。
如果“x”值等于“array_from”数组中的元素之一，则返回“array_to”数组中的现有元素（编号相同）。否则，它返回“默认”。如果 'array_from' 中有多个匹配元素，则返回其中一个匹配项。
例子：
SELECT
transform(SearchEngineID, [2, 3], ['Yandex', 'Google'], 'Other') AS title,
count() AS c
FROM test.hits
WHERE SearchEngineID != 0
GROUP BY title
ORDER BY c DESC
┌─title─────┬──────c─┐
│ Yandex │ 498635 │
│ Google │ 229872 │
│ Other │ 104472 │
└───────────┴────────┘
transform(x, array_from, array_to)
与第一个变体的不同之处在于省略了“默认”参数。如果“x”值等于“array_from”数组中的元素之一，则返回“array_to”数组中的匹配元素（编号相同）。否则，它返回“x”。
类型：
transform(T, Array(T), Array(T)) -> T
例子：
SELECT
transform(domain(Referer), ['yandex.ru', 'google.ru', 'vk.com'], ['www.yandex', 'example.com']) AS s,
count() AS c
FROM test.hits
GROUP BY domain(Referer)
ORDER BY count() DESC
LIMIT 10
┌─s──────────────┬───────c─┐
│ │ 2906259 │
│ www.yandex │ 867767 │
│ ███████.ru │ 313599 │
│ mail.yandex.ru │ 107147 │
│ ██████.ru │ 100355 │
│ █████████.ru │ 65040 │
│ news.yandex.ru │ 64515 │
│ ██████.net │ 59141 │
│ example.com │ 57316 │
└────────────────┴─────────┘
formatReadableSize(x )
接受大小（字节数）。以字符串形式返回带有后缀（KiB、MiB 等）的舍入大小。
例子：
SELECT
arrayJoin([1, 1024, 1024 * 1024, 192851925]) AS filesize_bytes,
formatReadableSize(filesize_bytes) AS filesize
Query id: 5f02c7c7-9ab8-4f3e-afc2-7bd943862b58
┌─filesize_bytes─┬─filesize───┐
│ 1 │ 1.00 B │
│ 1024 │ 1.00 KiB │
│ 1048576 │ 1.00 MiB │
│ 192851925 │ 183.92 MiB │
└────────────────┴────────────┘
formatReadableQuantity(x )
接受号码。返回一个带有后缀（千、百万、十亿等）的四舍五入的数字作为字符串。
它对于人类阅读大数字很有用。
例子：
SELECT
arrayJoin([1024, 1234 * 1000, (4567 * 1000) * 1000, 98765432101234]) AS number,
formatReadableQuantity(number) AS number_for_humans
Query id: 42c9f810-d1d9-43f8-92d4-7e14cfd71181
┌─────────number─┬─number_for_humans─┐
│ 1024 │ 1.02 thousand │
│ 1234000 │ 1.23 million │
│ 4567000000 │ 4.57 billion │
│ 98765432101234 │ 98.77 trillion │
└────────────────┴───────────────────┘
formatReadableTimeDelta
以秒为单位接受时间增量。返回一个时间增量（年、月、日、小时、分钟、秒）作为字符串。
句法
formatReadableTimeDelta(column[, maximum_unit])
论据
column— 具有数字时间增量的列。maximum_unit- 选修的。显示的最大单位。可接受的值秒、分钟、小时、天、月、年。
例子：
SELECT
arrayJoin([100, 12345, 432546534]) AS elapsed,
formatReadableTimeDelta(elapsed) AS time_delta
Query id: 4ebc34b2-d9e8-4ca0-94be-c6efaf84f13c
┌───elapsed─┬─time_delta──────────────────────────────────────────────────────┐
│ 100 │ 1 minute and 40 seconds │
│ 12345 │ 3 hours, 25 minutes and 45 seconds │
│ 432546534 │ 13 years, 8 months, 17 days, 7 hours, 48 minutes and 54 seconds │
└───────────┴─────────────────────────────────────────────────────────────────┘
SELECT
arrayJoin([100, 12345, 432546534]) AS elapsed,
formatReadableTimeDelta(elapsed, 'minutes') AS time_delta
Query id: ea2a6d6f-2d70-437b-8aa9-72d51ad22cff
┌───elapsed─┬─time_delta─────────────────────┐
│ 100 │ 1 minute and 40 seconds │
│ 12345 │ 205 minutes and 45 seconds │
│ 432546534 │ 7209108 minutes and 54 seconds │
└───────────┴────────────────────────────────┘
least(a, b)
返回 a 和 b 中的最小值。
greatest(a, b)
返回 a 和 b 的最大值。
SELECT
least(11, 45),
greatest(90, 34)
Query id: cfbd2f9b-3d6a-49c3-8735-f9d9d72ac7fa
┌─least(11, 45)─┬─greatest(90, 34)─┐
│ 11 │ 90 │
└───────────────┴──────────────────┘
uptime()
以秒为单位返回服务器的正常运行时间。如果它在分布式表的上下文中执行，那么它会生成一个普通列，其中包含与每个分片相关的值。否则它会产生一个常数值。
version()
以字符串形式返回服务器的版本。如果它在分布式表的上下文中执行，那么它会生成一个普通列，其中包含与每个分片相关的值。否则它会产生一个常数值。
buildId( )
返回编译器为正在运行的 ClickHouse 服务器二进制文件生成的构建 ID。如果它在分布式表的上下文中执行，那么它会生成一个普通列，其中包含与每个分片相关的值。否则它会产生一个常数值。
SELECT
uptime(),
version(),
buildId()
Query id: e362003d-5f79-4502-b66c-ab4a3cae70d2
┌─uptime()─┬─version()─┬─buildId()────────┐
│ 3482360 │ 22.2.2.1 │ 5F3D9E4F48D4CC47 │
└──────────┴───────────┴──────────────────┘
blockNumber
返回行所在数据块的序号。
rowNumberInBlock
返回数据块中行的序号。总是重新计算不同的数据块。
rowNumberInAllBlocks( )
返回数据块中行的序号。此函数仅考虑受影响的数据块。
SELECT
city,
blockNumber(),
rowNumberInBlock(),
rowNumberInAllBlocks()
FROM agg_table_basic
Query id: d6bc7af0-b76b-4a73-a391-31c54ddafdd3
┌─city───┬─blockNumber()─┬─rowNumberInBlock()─┬─rowNumberInAllBlocks()─┐
│ zhuhai │ 5 │ 0 │ 0 │
└────────┴───────────────┴────────────────────┴────────────────────────┘
┌─city──┬─blockNumber()─┬─rowNumberInBlock()─┬─rowNumberInAllBlocks()─┐
│ wuhan │ 6 │ 0 │ 1 │
│ wuhan │ 6 │ 1 │ 2 │
└───────┴───────────────┴────────────────────┴────────────────────────┘
neighbor
窗口函数提供对位于给定列的当前行之前或之后的指定偏移量处的行的访问。
句法
neighbor(column, offset[, default_value])
该函数的结果取决于受影响的数据块和块中数据的顺序。
警告
它只能到达当前处理的数据块内的相邻行。
计算期间使用的行顺序neighbor可能与返回给用户的行顺序不同。为防止可以使用ORDER BY进行子查询并从子查询外部调用该函数。
论据
column— 列名或标量表达式。offset— 从 的当前行向前或向后的行数column。整数 64。default_value- 选修的。偏移量超出块范围时返回的值。受影响的数据块类型。
返回值
- 如果值不在块边界之外，则值与当前行
column的offset距离。offset column如果offset值超出块边界的默认值。如果default_value给出，那么它将被使用。
类型：受影响的数据块类型或默认值类型。
例子
SELECT
number,
neighbor(number, 2)
FROM system.numbers
LIMIT 10
Query id: 4635839c-9907-4463-9ad2-bbc823ff1af3
┌─number─┬─neighbor(number, 2)─┐
│ 0 │ 2 │
│ 1 │ 3 │
│ 2 │ 4 │
│ 3 │ 5 │
│ 4 │ 6 │
│ 5 │ 7 │
│ 6 │ 8 │
│ 7 │ 9 │
│ 8 │ 0 │
│ 9 │ 0 │
└────────┴─────────────────────┘
SELECT
number,
neighbor(number, 2, 999)
FROM system.numbers
LIMIT 10
Query id: bda8c1bf-f382-4b56-9f86-1fa05a0ae3d8
┌─number─┬─neighbor(number, 2, 999)─┐
│ 0 │ 2 │
│ 1 │ 3 │
│ 2 │ 4 │
│ 3 │ 5 │
│ 4 │ 6 │
│ 5 │ 7 │
│ 6 │ 8 │
│ 7 │ 9 │
│ 8 │ 999 │
│ 9 │ 999 │
└────────┴──────────────────────────┘
此函数可用于计算同比指标值：
WITH toDate('2018-01-01') AS start_date
SELECT
toStartOfMonth(start_date + (number * 32)) AS month,
toInt32(month) % 100 AS money,
neighbor(money, -12) AS prev_year,
round(prev_year / money, 2) AS year_over_year
FROM numbers(16)
Query id: b3950e26-3ae1-4ae1-82d4-46ce2650d79a
┌──────month─┬─money─┬─prev_year─┬─year_over_year─┐
│ 2018-01-01 │ 32 │ 0 │ 0 │
│ 2018-02-01 │ 63 │ 0 │ 0 │
│ 2018-03-01 │ 91 │ 0 │ 0 │
│ 2018-04-01 │ 22 │ 0 │ 0 │
│ 2018-05-01 │ 52 │ 0 │ 0 │
│ 2018-06-01 │ 83 │ 0 │ 0 │
│ 2018-07-01 │ 13 │ 0 │ 0 │
│ 2018-08-01 │ 44 │ 0 │ 0 │
│ 2018-09-01 │ 75 │ 0 │ 0 │
│ 2018-10-01 │ 5 │ 0 │ 0 │
│ 2018-11-01 │ 36 │ 0 │ 0 │
│ 2018-12-01 │ 66 │ 0 │ 0 │
│ 2019-01-01 │ 97 │ 32 │ 0.33 │
│ 2019-02-01 │ 28 │ 63 │ 2.25 │
│ 2019-03-01 │ 56 │ 91 │ 1.62 │
│ 2019-04-01 │ 87 │ 22 │ 0.25 │
└────────────┴───────┴───────────┴────────────────┘
runningDifference(x)
计算数据块中连续行值的差值。第一行返回 0，随后的每一行返回与前一行的差值。
警告
它只能在当前处理的数据块内到达上一行。
该函数的结果取决于受影响的数据块和块中数据的顺序。
计算期间使用的行顺序runningDifference可能与返回给用户的行顺序不同。为防止可以使用ORDER BY进行子查询并从子查询外部调用该函数。
例子：
SELECT
EventID,
EventTime,
runningDifference(EventTime) AS delta
FROM
(
SELECT
EventID,
EventTime
FROM events
WHERE EventDate = '2016-11-24'
ORDER BY EventTime ASC
LIMIT 5
)
┌─EventID─┬───────────EventTime─┬─delta─┐
│ 1106 │ 2016-11-24 00:00:04 │ 0 │
│ 1107 │ 2016-11-24 00:00:05 │ 1 │
│ 1108 │ 2016-11-24 00:00:05 │ 0 │
│ 1109 │ 2016-11-24 00:00:09 │ 4 │
│ 1110 │ 2016-11-24 00:00:10 │ 1 │
└─────────┴─────────────────────┴───────┘
请注意 - 块大小会影响结果。对于每个新块，runningDifference状态都会重置。
SELECT
number,
runningDifference(number + 1) AS diff
FROM numbers(100000)
WHERE diff != 1
Query id: 2bedd7bb-9594-44cb-9ec8-a99ffb550894
┌─number─┬─diff─┐
│ 0 │ 0 │
└────────┴──────┘
┌─number─┬─diff─┐
│ 65505 │ 0 │
└────────┴──────┘
SET max_block_size = 100000
Query id: 0059d011-4e36-4e8f-a720-e3c1881d0d1f
Ok.
SELECT
number,
runningDifference(number + 1) AS diff
FROM numbers(100000)
WHERE diff != 1
Query id: 8fd4be11-2ea4-4fab-9561-5761674c4131
┌─number─┬─diff─┐
│ 0 │ 0 │
└────────┴──────┘
runningDifferenceStartingWithFirstValue
与runningDifference相同，差异是第一行的值，返回第一行的值，随后的每一行返回与前一行的差异。
runningConcurrency
计算并发事件的数量。每个事件都有开始时间和结束时间。开始时间包括在事件中，而结束时间不包括在内。具有开始时间和结束时间的列必须是相同的数据类型。该函数计算每个事件开始时间的活动（并发）事件总数。
警告
事件必须按开始时间升序排列。如果违反此要求，该函数将引发异常。每个数据块都是单独处理的。如果来自不同数据块的事件重叠，则无法正确处理它们。
句法
runningConcurrency(start, end)
论据
start— 包含事件开始时间的列。日期、日期时间或日期时间64 。end— 包含事件结束时间的列。 日期、日期时间或日期时间64 。
返回值
- 每个事件开始时间的并发事件数。
类型：UInt32
例子
考虑下表： ┌──────start─┬────────end─┐ │ 2021-03-03 │ 2021-03-11 │ │ 2021-03-06 │ 2021-03-12 │ │ 2021-03-07 │ 2021-03-08 │ │ 2021-03-11 │ 2021-03-12 │ └────────────┴────────────┘
SELECT start, runningConcurrency(start, end) FROM example_table; ┌──────start─┬─runningConcurrency(start, end)─┐ │ 2021-03-03 │ 1 │ │ 2021-03-06 │ 2 │ │ 2021-03-07 │ 3 │ │ 2021-03-11 │ 2 │ └────────────┴────────────────────────────────┘
MACNumToString(num )
接受一个 UInt64 数字。将其解释为大端格式的 MAC 地址。返回一个包含相应 MAC 地址的字符串，格式为 AA:BB:CC:DD:EE:FF（以冒号分隔的十六进制数字）。
MACStringToNum(s )
MACNumToString 的反函数。如果 MAC 地址的格式无效，则返回 0。
MACStringToOUI(s )
接受格式为 AA:BB:CC:DD:EE:FF（以冒号分隔的十六进制数字）的 MAC 地址。将前三个八位字节作为 UInt64 数字返回。如果 MAC 地址的格式无效，则返回 0。
SELECT
MACNumToString(1088777763456786),
MACStringToNum('00-1A-2B-3C-4D-56'),
MACStringToOUI('00-1A-2B-3C-4D-56')
Query id: 4dc4a623-36fa-4ac5-98be-fafae51533ac
┌─MACNumToString(1088777763456786)─┬─MACStringToNum('00-1A-2B-3C-4D-56')─┬─MACStringToOUI('00-1A-2B-3C-4D-56')─┐
│ DE:3C:D3:D4:87:12 │ 112394521942 │ 6699 │
└──────────────────────────────────┴─────────────────────────────────────┴─────────────────────────────────────┘
getSizeOfEnumType
返回Enum中的字段数。
getSizeOfEnumType(value)
论据：
value— 类型的值Enum。
返回值
Enum具有输入值的字段数。- 如果类型不是，则抛出异常
Enum。
SELECT getSizeOfEnumType(CAST('a', 'Enum8(\'a\' = 1, \'b\' = 2)')) AS x
Query id: 06b9563e-8298-4da8-b764-5c7cc758c305
┌─x─┐
│ 2 │
└───┘
blockSerializedSize
返回磁盘上的大小（不考虑压缩）。
blockSerializedSize(value[, value[, ...]])
论据
value— 任何值。
返回值
- 对于值块（不压缩）将写入磁盘的字节数。
例子
SELECT blockSerializedSize(maxState(111)) AS x Query id: 9f1bce0d-fefc-4067-bc04-a79313205e10 ┌─x─┐ │ 2 │ └───┘
toColumnTypeName
返回表示 RAM 中列的数据类型的类的名称。
toColumnTypeName(value)
论据：
value— 任何类型的值。
返回值
- 带有类名称的字符串，用于表示
valueRAM 中的数据类型。
之间的差异示例toTypeName ' and ' toColumnTypeName
SELECT toTypeName(CAST('2018-01-01 01:02:03', 'DateTime'))
Query id: fd7590df-41e0-46b7-a2d1-b07a3860fda1
┌─toTypeName(CAST('2018-01-01 01:02:03', 'DateTime'))─┐
│ DateTime │
└─────────────────────────────────────────────────────┘
SELECT toColumnTypeName(CAST('2018-01-01 01:02:03', 'DateTime'))
Query id: efb96dec-951b-4850-b59d-a993c76291aa
┌─toColumnTypeName(CAST('2018-01-01 01:02:03', 'DateTime'))─┐
│ Const(UInt32) │
└───────────────────────────────────────────────────────────┘
该示例显示DateTime数据类型在内存中存储为Const(UInt32).
dumpColumnStructure
输出 RAM 中数据结构的详细描述
dumpColumnStructure(value
论据：
value— 任何类型的值。
返回值
- 描述用于表示
valueRAM 中数据类型的结构的字符串。
例子
SELECT dumpColumnStructure(CAST('2018-01-01 01:02:03', 'DateTime'))
Query id: e54a4300-d1f0-4c85-a290-e3b27ab44966
┌─dumpColumnStructure(CAST('2018-01-01 01:02:03', 'DateTime'))─┐
│ DateTime, Const(size = 1, UInt32(size = 1)) │
└──────────────────────────────────────────────────────────────┘
defaultValueOfArgumentType
输出数据类型的默认值。
不包括用户设置的自定义列的默认值。
defaultValueOfArgumentType(expression)
论据：
expression— 任意类型的值或产生任意类型值的表达式。
返回值
0对于数字。- 字符串的空字符串。
ᴺᵁᴸᴸ为Nullable。
例子
SELECT defaultValueOfArgumentType(CAST(1, 'Int8')) Query id: 17c34d6e-751a-46c0-a599-d2c6668eca6e ┌─defaultValueOfArgumentType(CAST(1, 'Int8'))─┐ │ 0 │ └─────────────────────────────────────────────┘ SELECT defaultValueOfArgumentType(CAST(1, 'Nullable(Int8)')) Query id: 53d883ef-ac27-4d09-b332-5550b03b2ab2 ┌─defaultValueOfArgumentType(CAST(1, 'Nullable(Int8)'))─┐ │ ᴺᵁᴸᴸ │ └───────────────────────────────────────────────────────┘
defaultValueOfTypeName
输出给定类型名称的默认值。
不包括用户设置的自定义列的默认值。
defaultValueOfTypeName(type)
论据：
type— 表示类型名称的字符串。
返回值
0对于数字。- 字符串的空字符串。
ᴺᵁᴸᴸ为Nullable。
例子
SELECT defaultValueOfTypeName('Int8')
Query id: a88de7f0-493e-4894-8e4d-b1613a5c43d7
┌─defaultValueOfTypeName('Int8')─┐
│ 0 │
└────────────────────────────────┘
SELECT defaultValueOfTypeName('Nullable(Int8)')
Query id: d653f7f2-fcee-4085-92c1-ad18f05e8c98
┌─defaultValueOfTypeName('Nullable(Int8)')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────────────────────┘
indexHint
该函数用于调试和自省目的。该函数忽略它的参数并始终返回 1。甚至不计算参数。
但是出于索引分析的目的，该函数的参数被分析为就好像它直接存在而不被包装在indexHint函数中一样。这允许通过相应条件选择索引范围内的数据，但无需通过该条件进一步过滤。ClickHouse 中的索引是稀疏的，使用indexHint将产生比直接指定相同条件更多的数据。
句法
SELECT * FROM table WHERE indexHint(<expression>)
返回值
- 类型：Uint8。
例子
输入表：
SELECT count() FROM ontime
┌─count()─┐
│ 4276457 │
└─────────┘
--该表在字段上有索引(FlightDate, (Year, FlightDate))。
--创建一个查询，其中不使用索引。
SELECT FlightDate AS k, count() FROM ontime GROUP BY k ORDER BY k
--ClickHouse 处理了整个表 ( Processed 4.28 million rows)。
┌──────────k─┬─count()─┐
│ 2017-01-01 │ 13970 │
│ 2017-01-02 │ 15882 │
........................
│ 2017-09-28 │ 16411 │
│ 2017-09-29 │ 16384 │
│ 2017-09-30 │ 12520 │
└────────────┴─────────┘
--要应用索引，选择特定日期。
SELECT FlightDate AS k, count() FROM ontime WHERE k = '2017-09-15' GROUP BY k ORDER BY k
--通过使用索引，ClickHouse 处理的行数明显减少（Processed 32.74 thousand rows）。
┌──────────k─┬─count()─┐
│ 2017-09-15 │ 16428 │
└────────────┴─────────┘
--现在将表达式包装k = '2017-09-15'到indexHint函数中。
SELECT
FlightDate AS k,
count()
FROM ontime
WHERE indexHint(k = '2017-09-15')
GROUP BY k
ORDER BY k ASC
--ClickHouse 使用索引的方式与上次相同（Processed 32.74 thousand rows）。k = '2017-09-15'生成结果时未使用该表达式。例如，该indexHint功能允许查看相邻日期。
┌──────────k─┬─count()─┐
│ 2017-09-14 │ 7071 │
│ 2017-09-15 │ 16428 │
│ 2017-09-16 │ 1077 │
│ 2017-09-30 │ 8167 │
└────────────┴─────────┘
replicate
创建具有单个值的数组。
用于arrayJoin的内部实现。
SELECT replicate(x, arr);
论据：
arr— 原始数组。ClickHouse 创建一个与原始数组长度相同的新数组，并用 value 填充它x。x— 将填充结果数组的值。
返回值
一个用 value 填充的数组x。
类型：Array.
例子
SELECT replicate(1, ['a', 'b', 'c']) Query id: d01f6515-e918-435d-ab5f-4b725934c82b ┌─replicate(1, ['a', 'b', 'c'])─┐ │ [1,1,1] │ └───────────────────────────────┘
filesystemAvailable
返回数据库文件所在的文件系统上的剩余空间量。它总是小于总可用空间（filesystemFree），因为为操作系统保留了一些空间。
句法
filesystemAvailable()
返回值
- 可用的剩余空间量（以字节为单位）。
类型：UInt64。
例子
SELECT
formatReadableSize(filesystemAvailable()) AS `Available space`,
toTypeName(filesystemAvailable()) AS Type
Query id: 19750346-711a-456c-b3b0-76ca73764524
┌─Available space─┬─Type───┐
│ 75.90 GiB │ UInt64 │
└─────────────────┴────────┘
filesystemFree
返回数据库文件所在的文件系统上的可用空间总量。也可以看看filesystemAvailable
句法
filesystemFree()
返回值
- 可用空间量（以字节为单位）。
类型：UInt64。
例子
SELECT
formatReadableSize(filesystemFree()) AS `Free space`,
toTypeName(filesystemFree()) AS Type
Query id: 576e4ce5-2a87-4171-87f9-3ef2ab246370
┌─Free space─┬─Type───┐
│ 75.90 GiB │ UInt64 │
└────────────┴────────┘
filesystemCapacity
返回文件系统的容量（以字节为单位）。对于评估，必须配置数据目录的路径。
句法
filesystemCapacity()
返回值
- 文件系统的容量信息（以字节为单位）。
类型：UInt64。
例子
SELECT
formatReadableSize(filesystemCapacity()) AS Capacity,
toTypeName(filesystemCapacity()) AS Type
Query id: 4cbf76b8-be9a-457e-b89d-39083931ab06
┌─Capacity───┬─Type───┐
│ 182.97 GiB │ UInt64 │
└────────────┴────────┘
initializeAggregation
基于单个值计算聚合函数的结果。它旨在使用此函数通过组合器-State初始化聚合函数。可以创建聚合函数的状态并将它们插入到AggregateFunction类型的列中，或者使用初始化的聚合作为默认值。
句法
initializeAggregation (aggregate_function, arg1, arg2, ..., argN)
论据
aggregate_function— 要初始化的聚合函数的名称。字符串。arg— 聚合函数的参数。
返回值
- 传递给函数的每一行的聚合结果。
返回类型与函数的返回类型相同，initializeAgregation作为第一个参数。
例子
SELECT uniqMerge(state)
FROM
(
SELECT initializeAggregation('uniqState', number % 3) AS state
FROM numbers(10000)
)
Query id: d29f0bb3-9edc-425d-b6ba-e71b52218db8
┌─uniqMerge(state)─┐
│ 3 │
└──────────────────┘
SELECT
finalizeAggregation(state),
toTypeName(state)
FROM
(
SELECT initializeAggregation('sumState', number % 3) AS state
FROM numbers(5)
)
Query id: 09a5317a-7542-4feb-8997-0a9b4965a0a8
┌─finalizeAggregation(state)─┬─toTypeName(state)─────────────┐
│ 0 │ AggregateFunction(sum, UInt8) │
│ 1 │ AggregateFunction(sum, UInt8) │
│ 2 │ AggregateFunction(sum, UInt8) │
│ 0 │ AggregateFunction(sum, UInt8) │
│ 1 │ AggregateFunction(sum, UInt8) │
└────────────────────────────┴───────────────────────────────┘
AggregatingMergeTree表引擎和AggregateFunction列的示例：
CREATE TABLE metrics
(
key UInt64,
value AggregateFunction(sum, UInt64) DEFAULT initializeAggregation('sumState', toUInt64(0))
)
ENGINE = AggregatingMergeTree
ORDER BY key
INSERT INTO metrics VALUES (0, initializeAggregation('sumState', toUInt64(42)))
finalizeAggregation
获取聚合函数的状态。返回聚合结果（或使用-State组合器时的最终状态）。
句法
finalizeAggregation(state)
论据
state— 聚合状态。聚合函数。
返回值
- 聚合的值/值。
类型：聚合的任何类型的值。
例子
SELECT finalizeAggregation((
SELECT countState(number)
FROM numbers(10)
))
Query id: 54324524-60c4-4934-8784-7c2e6e8cbfae
┌─finalizeAggregation(_subquery389)─┐
│ 10 │
└───────────────────────────────────┘
SELECT finalizeAggregation((
SELECT sumState(number)
FROM numbers(10)
))
Query id: a955a50e-51b9-488e-865a-252c0ddb6a2b
┌─finalizeAggregation(_subquery390)─┐
│ 45 │
└───────────────────────────────────┘
SELECT finalizeAggregation(arrayReduce('anyState', [NULL, 2, 3]))
Query id: 83f2bdd6-543b-44c9-9575-3adf5d030752
┌─finalizeAggregation(arrayReduce('anyState', [NULL, 2, 3]))─┐
│ 2 │
└────────────────────────────────────────────────────────────┘
WITH initializeAggregation('sumState', number) AS one_row_sum_state
SELECT
number,
finalizeAggregation(one_row_sum_state) AS one_row_sum,
runningAccumulate(one_row_sum_state) AS cumulative_sum
FROM numbers(10)
Query id: 1a84f0a5-6e79-4fca-be4a-26601374f406
┌─number─┬─one_row_sum─┬─cumulative_sum─┐
│ 0 │ 0 │ 0 │
│ 1 │ 1 │ 1 │
│ 2 │ 2 │ 3 │
│ 3 │ 3 │ 6 │
│ 4 │ 4 │ 10 │
│ 5 │ 5 │ 15 │
│ 6 │ 6 │ 21 │
│ 7 │ 7 │ 28 │
│ 8 │ 8 │ 36 │
│ 9 │ 9 │ 45 │
└────────┴─────────────┴────────────────┘
runningAccumulate
为数据块的每一行累积聚合函数的状态。
警告
为每个新数据块重置状态。
句法
runningAccumulate(agg_state[, grouping]);
论据
agg_state— 聚合函数的状态。聚合函数。grouping— 分组键。选修的。grouping如果值改变，函数的状态会被重置。它可以是定义了相等运算符的任何受支持的数据类型。
返回值
- 每个结果行都包含聚合函数的结果，从 0 到当前位置的所有输入行累加。
runningAccumulate为每个新数据块或grouping值更改时重置状态。
类型取决于使用的聚合函数。
例子
考虑如何使用runningAccumulate分组和分组来查找数字的累积总和。
SELECT
k,
runningAccumulate(sum_k) AS res
FROM
(
SELECT
number AS k,
sumState(k) AS sum_k
FROM numbers(10)
GROUP BY k
ORDER BY k ASC
)
Query id: ca27bc00-a029-43b5-9fa7-752a5d5303db
┌─k─┬─res─┐
│ 0 │ 0 │
│ 1 │ 1 │
│ 2 │ 3 │
│ 3 │ 6 │
│ 4 │ 10 │
│ 5 │ 15 │
│ 6 │ 21 │
│ 7 │ 28 │
│ 8 │ 36 │
│ 9 │ 45 │
└───┴─────┘
子查询为从到sumState的每个数字生成。返回包含单个数字总和的sum函数的状态。
整个查询执行以下操作：
- 对于第一行，
runningAccumulate接受sumState(0)并返回0。 - 对于第二行，函数合并
sumState(0)并sumState(1)产生sumState(0 + 1)，并1作为结果返回。 - 对于第三行，函数合并
sumState(0 + 1)并sumState(2)产生sumState(0 + 1 + 2)，并3作为结果返回。 - 重复这些动作，直到块结束。
以下示例显示了groupping参数用法：
SELECT
grouping,
item,
runningAccumulate(state, grouping) AS res
FROM
(
SELECT
toInt8(number / 4) AS grouping,
number AS item,
sumState(number) AS state
FROM numbers(15)
GROUP BY item
ORDER BY item ASC
)
Query id: 25d9c00e-b3d0-4dee-924e-89ab452e6dab
┌─grouping─┬─item─┬─res─┐
│ 0 │ 0 │ 0 │
│ 0 │ 1 │ 1 │
│ 0 │ 2 │ 3 │
│ 0 │ 3 │ 6 │
│ 1 │ 4 │ 4 │
│ 1 │ 5 │ 9 │
│ 1 │ 6 │ 15 │
│ 1 │ 7 │ 22 │
│ 2 │ 8 │ 8 │
│ 2 │ 9 │ 17 │
│ 2 │ 10 │ 27 │
│ 2 │ 11 │ 38 │
│ 3 │ 12 │ 12 │
│ 3 │ 13 │ 25 │
│ 3 │ 14 │ 39 │
└──────────┴──────┴─────┘
如所见，runningAccumulate分别合并每组行的状态。
joinGet
该函数使可以像从字典中提取数据一样从表中提取数据。
使用指定的连接键从连接表中获取数据。
仅支持使用该ENGINE = Join(ANY, LEFT, <join_keys>)语句创建的表。
句法
joinGet(join_storage_table_name, `value_column`, join_keys)
论据
join_storage_table_name—标识符指示执行搜索的位置。在默认数据库中搜索标识符（请参阅default_database配置文件中的参数）。要覆盖默认数据库，请使用USE db_name或 通过分隔符指定数据库和表db_name.db_table，请参见示例。value_column— 包含所需数据的表列的名称。join_keys— 键列表。
返回值
返回对应于键列表的值列表。
如果源表中不存在某些，则0或null将根据join_use_nulls设置返回。
join_use_nulls有关加入操作的更多信息。
例子
CREATE DATABASE db_test CREATE TABLE db_test.id_val(`id` UInt32, `val` UInt32) ENGINE = Join(ANY, LEFT, id) SETTINGS join_use_nulls = 1 INSERT INTO db_test.id_val VALUES (1,11)(2,12)(4,13) ┌─id─┬─val─┐ │ 4 │ 13 │ │ 2 │ 12 │ │ 1 │ 11 │ └────┴─────┘ SELECT joinGet(db_test.id_val,'val',toUInt32(number)) from numbers(4) SETTINGS join_use_nulls = 1 ┌─joinGet(db_test.id_val, 'val', toUInt32(number))─┐ │ 0 │ │ 11 │ │ 12 │ │ 0 │ └──────────────────────────────────────────────────┘
modelEvaluate(model_name, ... )
评估外部模型。接受模型名称和模型参数。返回 Float64。
throwIf(x [ , custom_message ] )
如果参数不为零，则抛出异常。custom_message - 是一个可选参数：一个常量字符串，提供错误消息
SELECT throwIf(number = 3, 'Too many') FROM numbers(10);
identity
返回用作其参数的相同值。用于调试和测试，允许取消使用索引，获得全扫描的查询性能。当分析查询以查找可能使用的索引时，分析器不会查看identity函数内部。也不应用恒定折叠。
句法
identity(x)
例子
SELECT identity(42) Query id: a69250f6-f29d-4e3a-82a5-4f5102667af7 ┌─identity(42)─┐ │ 42 │ └──────────────┘
randomPrintableASCII
生成带有随机ASCII可打印字符集的字符串。
句法
randomPrintableASCII(length)
论据
-
如果传递 `length < 0`，则函数的行为未定义。length— 生成的字符串长度。正整数。
返回值
- 带有一组随机ASCII可打印字符的字符串。
类型：字符串
例子
SELECT
number,
randomPrintableASCII(30) AS str,
length(str)
FROM system.numbers
LIMIT 3
Query id: 8cee7c6e-2cc6-4016-b8c6-edb238eb40e9
┌─number─┬─str────────────────────────────┬─length(randomPrintableASCII(30))─┐
│ 0 │ ja+hJ1JXbbOw)nRYgy0a\>->:+:|\; │ 30 │
│ 1 │ zvdB%itCCFefF#fTiJ+GQXs_I@=|"U │ 30 │
│ 2 │ 9{Z\;vCsk`w/`I4*2UDpKMB8V\>x.q │ 30 │
└────────┴────────────────────────────────┴──────────────────────────────────┘
randomString
生成由随机字节（包括零字节）填充的指定长度的二进制字符串。
句法
randomString(length)
论据
length— 字符串长度。正整数。
返回值
- 用随机字节填充的字符串。
类型：字符串。
例子
SELECT
randomString(30) AS str,
length(str) AS len
FROM numbers(2)
FORMAT Vertical
Query id: de5c0318-6cd8-46fd-9894-94b5e052a015
Row 1:
──────
str: u·rvI¡J±i?¶sԴYs-cmF}
len: 30
Row 2:
──────
str: hb标签：返回,函数,二十九,clickhouse,返回值,字符串,Query,id,SELECT
来源： https://www.cnblogs.com/MrYang-11-GetKnow/p/16205872.html