二十九、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— 生成的字符串长度。正整数。

如果传递 `length < 0`，则函数的行为未定义。

返回值

带有一组随机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򐇨ۦCUS+!T:¬U
len: 30

　　randomFixedString

　　生成由随机字节（包括零字节）填充的指定长度的二进制字符串。

　　句法

randomFixedString(length);

　　论据

length— 字符串长度（以字节为单位）。UInt64。

　　返回值

用随机字节填充的字符串。

　　类型：固定字符串。

　　例子SELECT

    randomFixedString(13) AS rnd,
    toTypeName(rnd)

Query id: ee30d664-4368-421d-8921-b7b3b14c8550

┌─rnd─┬─toTypeName(randomFixedString(13))─┐
│ K߱츋¸󡢔 FixedString(13)                   │
└─────┴───────────────────────────────────┘
　　randomStringUTF8

randomStringUTF8(length);

　论据

length— 结果字符串的所需长度（以代码点为单位）。UInt64。

　　返回值

UTF-8 随机字符串。

　　类型：字符串。

　　例子

SELECT randomStringUTF8(13)

Query id: 7f9027aa-3a2c-4a65-a847-50db809a0436

┌─randomStringUTF8(13)─┐
│ 𔧒𳊨󯢽󩙎𬔵ꗶ𑅻𜟰዇飝𝇭𿷝𪿽          │
└──────────────────────┘
　　getSetting

　　返回自定义设置的当前值。

　　句法

getSetting('custom_setting');

　范围

custom_setting— 设置名称。字符串。

　　返回值

设定电流值。

　　例子

SET custom_a = 123;
SELECT getSetting('custom_a');


123

　　isDecimalOverflow

　　检查Decimal值是否超出其（或指定）精度。

　　句法

isDecimalOverflow(d, [p])

　　论据

d- 值。十进制。
p- 精确。选修的。如果省略，则使用第一个参数的初始精度。使用此参数可能有助于将数据提取到另一个 DBMS 或文件。UInt8。

　　返回值

1— 十进制值的位数比精度允许的多，
0— 十进制值满足指定的精度。

　　例子

SELECT
    isDecimalOverflow(toDecimal32(1000000000, 0), 9),
    isDecimalOverflow(toDecimal32(1000000000, 0)),
    isDecimalOverflow(toDecimal32(-1000000000, 0), 9),
    isDecimalOverflow(toDecimal32(-1000000000, 0))

Query id: e835a9ff-7700-47b6-bbef-7e9f97bfca27

┌─isDecimalOverflow(toDecimal32(1000000000, 0), 9)─┬─isDecimalOverflow(toDecimal32(1000000000, 0))─┬─isDecimalOverflow(toDecimal32(-1000000000, 0), 9)─┬─isDecimalOverflow(toDecimal32(-1000000000, 0))─┐
│                                                1 │                                             1 │                                                 1 │                                              1 │
└──────────────────────────────────────────────────┴───────────────────────────────────────────────┴───────────────────────────────────────────────────┴────────────────────────────────────────────────┘
　　countDigits

　　返回表示值所需的小数位数。

　　句法

countDigits(x)

　　论据

x— Int或Decimal值。

　　返回值

　　位数。

　　类型：UInt8。

　　笔记

　　对于Decimal值，考虑到它们的比例：计算基础整数类型的结果，即(value * scale). 例如：countDigits(42) = 2, countDigits(42.000) = 5, countDigits(0.04200) = 4。Decimal64即你可以用来检查十进制溢出countDecimal(x) > 18。这是isDecimalOverflow的缓慢变体。

　　例子

SELECT
    countDigits(toDecimal32(1, 9)),
    countDigits(toDecimal32(-1, 9)),
    countDigits(toDecimal64(1, 18)),
    countDigits(toDecimal64(-1, 18)),
    countDigits(toDecimal128(1, 38)),
    countDigits(toDecimal128(-1, 38))

Query id: f9cd77e2-3a51-43c8-b9b5-92839fd7eed6

┌─countDigits(toDecimal32(1, 9))─┬─countDigits(toDecimal32(-1, 9))─┬─countDigits(toDecimal64(1, 18))─┬─countDigits(toDecimal64(-1, 18))─┬─countDigits(toDecimal128(1, 38))─┬─countDigits(toDecimal128(-1, 38))─┐
│                             10 │                              10 │                              19 │                               19 │                               39 │                                39 │
└────────────────────────────────┴─────────────────────────────────┴─────────────────────────────────┴──────────────────────────────────┴──────────────────────────────────┴───────────────────────────────────┘
　　errorCodeToName

　　返回值

错误代码的变量名称。

　　类型：低基数（字符串）。

　　句法

errorCodeToName(1)

SELECT errorCodeToName(1)

Query id: b5c03d4b-6ba9-4991-92c5-5447df212891

┌─errorCodeToName(1)─┐
│ UNSUPPORTED_METHOD │
└────────────────────┘
　　tcpPort

　　返回此服务器侦听的本机接口TCP 端口号。如果它是在分布式表的上下文中执行的，那么它会生成一个普通的列，否则它会生成一个常量值。

　　句法

tcpPort()

　　论据

没有任何。

　　返回值

TCP 端口号。

　　类型：UInt16。

　　例子

SELECT tcpPort()

Query id: 82757961-487d-4de4-a9de-145fe59fa4e9

┌─tcpPort()─┐
│      9000 │
└───────────┘
　　currentProfiles

　　返回当前用户的当前设置配置文件列表。

　　命令SET PROFILE可用于更改当前设置配置文件。如果SET PROFILE未使用该命令，该函数将返回当前用户定义中指定的配置文件（请参阅CREATE USER）。

　　句法

currentProfiles()

　返回值

当前用户设置配置文件的列表。

　　类型：数组（字符串）。

SELECT currentProfiles()

Query id: 8965a2e5-41bc-4184-afbd-1ff378985e26

┌─currentProfiles()─┐
│ ['default']       │
└───────────────────┘

　　enabledProfiles

　　返回设置配置文件，显式和隐式分配给当前用户。显式分配的配置文件与currentProfiles函数返回的配置文件相同。隐式分配的配置文件包括其他已分配配置文件的父配置文件、通过授予角色分配的配置文件、通过它们自己的设置分配的配置文件以及主要的默认配置文件（请参阅default_profile主服务器配置文件中的部分）。

　　句法

enabledProfiles()

返回值

启用的设置配置文件列表。

　　类型：数组（字符串）。

SELECT enabledProfiles()

Query id: 45882e16-1de9-4bbd-adbd-11d15160ef94

┌─enabledProfiles()─┐
│ ['default']       │
└───────────────────┘

　　defaultProfiles

　　返回当前用户定义中指定的所有配置文件（请参阅CREATE USER语句）。

　　句法

defaultProfiles()

　　返回值

默认设置配置文件列表。

　　类型：数组（字符串）。

SELECT defaultProfiles()

Query id: 44a59496-5d71-4b89-b8f9-8b419335faf1

┌─defaultProfiles()─┐
│ ['default']       │
└───────────────────┘

　　currentRoles

　　返回当前用户当前角色的名称。当前角色可以通过SET ROLE语句进行更改。如果SET ROLE未使用该语句，则该函数currentRoles返回与相同的值defaultRoles。

　　句法

currentRoles()

　返回值

当前用户的当前角色列表。

　　类型：数组（字符串）。

SELECT currentRoles()

Query id: 71593499-2cdb-47b5-8a2d-e3a5448c5922

┌─currentRoles()─┐
│ []             │
└────────────────┘

　　enabledRoles

　　返回当前角色的名称和授予某些当前角色的角色。

　　句法

enabledRoles()

　　返回值

当前用户启用的角色列表。

　　类型：数组（字符串）。

SELECT enabledRoles()

Query id: 6c8afa0e-5fb6-4bc9-b0b6-278e15e04a2b

┌─enabledRoles()─┐
│ []             │
└────────────────┘

　　defaultRoles

　　返回当前用户登录时默认启用的角色名称。最初，这些都是授予当前用户的所有角色（请参阅GRANT），但可以使用SET DEFAULT ROLE语句进行更改。

　　句法

defaultRoles()

　　返回值

当前用户的默认角色列表。

　　类型：数组（字符串）。

SELECT defaultRoles()

Query id: 4d90a6c0-09e0-4c82-9636-3023ad5cc057

┌─defaultRoles()─┐
│ []             │
└────────────────┘

　　getServerPort

　　返回服务器端口号。当该端口未被服务器使用时，抛出异常。

　　句法

getServerPort(port_name)

论据

port_name— 服务器端口的名称。字符串。可能的值：
- 'tcp_port'
- 'tcp_port_secure'
- 'http_port'
- 'https_port'
- 'interserver_http_port'
- 'interserver_https_port'
- 'mysql_port'
- 'postgresql_port'
- 'grpc_port'
- ''prometheus.port'

　　返回值

服务器端口号。

　　类型：UInt16。

　　例子

SELECT getServerPort('tcp_port')

Query id: 28017387-1b1e-48b2-84e9-d9b6626dc5e8

┌─getServerPort('tcp_port')─┐
│                      9000 │
└───────────────────────────┘
　　queryID

　　返回当前查询的 ID。查询的其他参数可以通过system.query_log表提取query_id。

　　与initialQueryID函数相比，queryID它可以在不同的分片上返回不同的结果（参见示例）。

　　句法

queryID()
 　返回值

当前查询的 ID。

　　类型：字符串

　　例子

CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT queryID() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());



┌─count()─┐
│ 3       │
└─────────┘
　　initialQueryID

　　返回初始当前查询的 ID。查询的其他参数可以通过system.query_log表提取initial_query_id。

　　与queryID函数相比，initialQueryID它在不同的分片上返回相同的结果（参见示例）。

　　句法

initialQueryID()

返回值

初始当前查询的 ID。

　　类型：字符串

　　例子

CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT initialQueryID() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());



┌─count()─┐
│ 1       │
└─────────┘
　　shardNum

　　返回为分布式查询处理部分数据的分片的索引。索引从开始1。如果查询未分发，则0返回常量值。

　　句法

shardNum()

返回值

分片索引或常量0。

　　类型：UInt32。

　　例子

　　在以下示例中，使用了具有两个分片的配置。查询在每个分片上的system.one表上执行。

CREATE TABLE shard_num_example (dummy UInt8) 
    ENGINE=Distributed(test_cluster_two_shards_localhost, system, one, dummy);
SELECT dummy, shardNum(), shardCount() FROM shard_num_example;



┌─dummy─┬─shardNum()─┬─shardCount()─┐
│     0 │          2 │            2 │
│     0 │          1 │            2 │
└───────┴────────────┴──────────────┘
　　shardCount

　　返回分布式查询的分片总数。如果查询未分发，则0返回常量值。

　　句法

shardCount()

　返回值

分片总数或0.

　　类型：UInt32。

　　getOSKernelVersion

　　返回具有当前操作系统内核版本的字符串。

　　句法

getOSKernelVersion()

　　论据

没有任何。

　　返回值

当前操作系统内核版本。

　　类型：字符串。

　　例子

SELECT getOSKernelVersion()

Query id: 30889d00-4724-49d6-81a3-afd37879a0da

┌─getOSKernelVersion()──────────────┐
│ Linux 5.12.11-1.el7.elrepo.x86_64 │
└───────────────────────────────────┘
　　zookeeperSessionUptime

　　返回当前 ZooKeeper 会话的正常运行时间（以秒为单位）。

　　句法

zookeeperSessionUptime()

　返回值

当前 ZooKeeper 会话的正常运行时间（以秒为单位）。

　　类型：UInt32。

　　例子

SELECT zookeeperSessionUptime();



┌─zookeeperSessionUptime()─┐
│                      286 │
└──────────────────────────┘

成指定长度的随机字符串。结果字符串包含有效的 UTF-8 代码点。代码点的值可能超出分配的 Unicode 范围。

posted @ 2022-04-29 15:28 渐逝的星光阅读(937) 评论(0) 编辑收藏举报

刷新页面返回顶部

渐逝的星光

云卷云舒风入怀，潮涨潮落月洗尘。

二十九、clickhouse其他函数

hostName

getMacro

FQDN

basename

visibleWidth(x )

toTypeName(x )

blockSize( )

byteSize

materialize(x)

ignore(…)

sleep(seconds)

sleepEachRow(seconds)

currentDatabase()

currentUser()

isConstant

isFinite(x)

isInfinite(x)

ifNotFinite

isNaN (x )

hasColumnInTable([‘hostname’[, ‘username’[, ‘password’]],] ‘database’, ‘table’, ‘column’)

bar

transform

transform(x, array_from, array_to, default)

transform(x, array_from, array_to)

formatReadableSize(x )

formatReadableQuantity(x )

formatReadableTimeDelta

least(a, b)

greatest(a, b)

uptime()

version()

buildId( )

blockNumber

rowNumberInBlock

rowNumberInAllBlocks( )

neighbor

警告

警告

runningDifferenceStartingWithFirstValue

runningConcurrency

警告

MACNumToString(num )

MACStringToNum(s )

MACStringToOUI(s )

getSizeOfEnumType

blockSerializedSize

toColumnTypeName

dumpColumnStructure

defaultValueOfArgumentType

defaultValueOfTypeName

indexHint

replicate

filesystemAvailable

filesystemFree

filesystemCapacity

initializeAggregation

finalizeAggregation

runningAccumulate

警告

joinGet

modelEvaluate(model_name, ... )

throwIf(x [ , custom_message ] )

identity

randomPrintableASCII

randomString

randomFixedString

randomStringUTF8

getSetting

isDecimalOverflow

countDigits

笔记

errorCodeToName

tcpPort

currentProfiles

enabledProfiles

defaultProfiles

currentRoles

　　hostName

　　getMacro

　　FQDN

　basename

　　visibleWidth(x )

　　toTypeName(x )

　　blockSize( )

　　byteSize

　　materialize(x)

　　ignore(…)

　　sleep(seconds)

　　sleepEachRow(seconds)

　　currentDatabase()

　　currentUser()

　　isConstant

　　isFinite(x)

　　isInfinite(x)

　　ifNotFinite

　isNaN (x )

　　hasColumnInTable([‘hostname’[, ‘username’[, ‘password’]],] ‘database’, ‘table’, ‘column’)

　　bar

　　transform

　　transform(x, array_from, array_to, default)

　　transform(x, array_from, array_to)

　　formatReadableSize(x )

　　formatReadableQuantity(x )

　　formatReadableTimeDelta

　　least(a, b)

　　greatest(a, b)

　　uptime()

　　version()

　　buildId( )

　　blockNumber

　　rowNumberInBlock

　　rowNumberInAllBlocks( )

　　neighbor

　　警告

　　警告

　　runningDifferenceStartingWithFirstValue

　　runningConcurrency

　　警告

　　MACNumToString(num )

　　MACStringToNum(s )

　　MACStringToOUI(s )

　　getSizeOfEnumType

　　blockSerializedSize

　　toColumnTypeName

　　dumpColumnStructure

　　defaultValueOfArgumentType

　　defaultValueOfTypeName

　　indexHint

　　replicate

　　filesystemAvailable

　　filesystemFree

　　filesystemCapacity

　　initializeAggregation

　　runningAccumulate

　　警告

　　joinGet

　　modelEvaluate(model_name, ... )

　　throwIf(x [ , custom_message ] )

　　identity

　　randomPrintableASCII

　　randomString

　　randomFixedString

　　randomStringUTF8

　　getSetting

　　isDecimalOverflow

　　countDigits

　　笔记

　　errorCodeToName

　　tcpPort

　　currentProfiles

　　enabledProfiles

　　defaultProfiles

　　currentRoles

　　enabledRoles

　　defaultRoles

　　getServerPort

　　queryID