Clickhouse常用函数总结

目录

• [1. 算术函数](#1. 算术函数)
• [2. 比较运算](#2. 比较运算)
• [3. 逻辑函数](#3. 逻辑函数)
• [4. 数组函数](#4. 数组函数)
• [5. 时间日期函数](#5. 时间日期函数)
• [6. 字典函数](#6. 字典函数)
• [7. Nullable处理函数](#7. Nullable处理函数)
• [8. IP函数](#8. IP函数)
• [9. 字符串拆分合并函数](#9. 字符串拆分合并函数)
• [10. 字符串函数](#10. 字符串函数)
• [11. 字符串替换函数](#11. 字符串替换函数)
• [12. 聚合函数](#12. 聚合函数)
• 参考文献

原文地址：****https://program-park.top/2023/09/26/clickhouse_17/

1. 算术函数

算术运算符适用于 UInt8，UInt16，UInt32，UInt64，Int8，Int16，Int32，Int64，Float32，Float64 等类型。

• plus(a, b), a + b
  • 计算数值的总和，也可将日期与整数进行相加；
  • 在 Date 的情况下，和整数相加意味着添加相应的天数；
  • 在 DateTime 的情况下，和整数相加意味着添加相应的秒数。
• minus(a, b), a - b
  • 计算数值之间的差，也可将日期与整数进行相减，同plus一样。
• multiply(a, b), a * b
  • 计算数值的乘积。
• divide(a, b), a / b
  • 计算数值的商，结果类型是浮点类型；
  • 当除以 0 时，结果为inf，-inf或nan。
• intDiv(a, b)
  • 计算数值的商；
  • 如果结果是正数，则向下取整；
  • 如果结果是负数，则向上取整；
  • 如果除数是 0 或用最小除数(-9223372036854775808)除以 -1 时，则抛异常。
• intDivOrZero(a, b)
  • 用法与intDiv相同；
  • 区别在于它在除以零或将最小负数除以 -1 时返回零。
• modulo(a, b), a % b
  • 计算除法后的余数；
  • 如果类型是整数，则结果类型也是整数；
  • 如果其中一个参数是浮点数，则结果类型也是浮点数；
  • 除以 0 或将最小负数除以 -1 时抛出异常。
• moduloOrZero(a, b)
  • 用法与modulo相同；
  • 区别在于它在除以零或将最小负数除以 -1 时返回零。
• negate(a), -a
  • 计算数值的相反数。
• abs(a)
  • 计算数值的绝对值；
  • 对于无符号类型，它不执行任何操作（个人觉得这句话是废话，感兴趣的可以自己去测试下无符号类型toUInt8(-257)）；
  • 对于有符号整数类型，它返回无符号数。
• gcd(a, b)
  • 计算两个值的最大公约数；
  • 其中一个值为 0 时抛出异常。
• lcm(a, b)
  • 计算两个值的最小公倍数；
  • 其中一个值为 0 时抛出异常。
• max2(a, b)
  • 比较两个值并返回最大值，返回值为Float64类型。
• min2(a, b)
  • 比较两个值并返回最小值，返回值为Float64类型。

2. 比较运算

比较运算符始终返回 0 或 1 (UInt8)。

可以比较以下几种类型：

• 数字
• String 和 FixedString
• 日期
• 日期时间

以上每组内的类型均可互相比较，但是不同组的类型间不能进行比较。

• equals(a, b)，a = b，a == b
  • 等于
• notEquals(a, b)，a != b，a <> b
  • 不等于
• less(a, b)，a < b
  • 小于
• greater(a, b)，a > b
  • 大于
• lessOrEquals(a, b)，a <= b
  • 小于等于
• greaterOrEquals(a, b)，a >= b
  • 大于等于

3. 逻辑函数

逻辑函数可以接受任何数字类型的参数，并返回UInt8类型的 0 或 1。

当向函数传递 0 时，函数将判定为false，任何其他非 0 的值都将被判定为true。

• and(a, b, ...)，a AND b AND ...
  • 与，计算两个或多个值之间的逻辑与结果，如果有条件为 0，则结果为 0，如果有条件为NULL，则结果为NULL。
• or(a, b, ...)，a OR b OR ...
  • 或，计算两个或多个值之间的逻辑或结果。如果有条件为 1，则结果为 1，如果有条件为NULL，则结果为NULL。
• not(a)
  • 非，值为 0 时返回 1，值为非 0 时返回 0，值为NULL时返回NULL。
• xor(a, b, ...)
  • 异或。

4. 数组函数

• empty()

  • 检测输入的数组是否为空，空数组返回 1，非空数组返回 0。

• notEmpty()

  • 检测输入的数组是否非空，空数组返回 0，非空数组返回 1。

• length()

  • 返回数组中的元素个数，结果类型是UInt64，该函数也适用于字符串。

• range(end)，range(start, end, step)

  • 返回一个以step作为增量步长的从start到end-1的整形数字数组；
  • 所有参数 start、end、step 必须属于以下几种类型之一：UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64。

• array(x1, x2, ...)

  • 使用函数的参数作为数组元素创建一个数组；
  • 参数必须是常量，并且具有最小公共类型的类型。

• arrayConcat(arr1, arr2, ...)

  • 合并参数中传递的所有数组。

• arrayElement(arr, n)，arr[n]

  • 获取数组arr中索引为n的元素，n必须是整数类型；
  • 如果索引超出数组的长度，则返回默认值（数字为 0，字符串为空字符串）。

• has(arr, elem)

  • 判断数组arr中是否存在元素elem，如果存在，则返回 1，不存在返回 0。

• hasAll(arr1, arr2)

  • 判断arr2是否是arr1的子集，如果是返回 1，不是返回 0；
  • 空数组是任何数组的子集，NULL在数组中作为元素值进行处理。

• hasAny(arr1, arr2)

  • 判断两个数组是否存在交集，如果存在返回 1，不存在返回 0。

• hasSubstr(arr1, arr2)

  • 判断arr2的所有元素是否以相同的顺序存在于arr1中，如果存在返回 1，不存在返回 0。

• indexOf(arr, x)

  • 返回数组中第一个x元素的索引（从 1 开始计算），如果x不存在该数组中则返回 0。

• countEqual(arr, x)

  • 返回数组中等于x元素的个数。

• arrayEnumerate(arr)

  • 返回数组元素下标，如：Array[1,2,3,...,length(arr)]。

• arrayEnumerateUniq(arr1, arr2, ...)

  • 返回与数组大小相同的数组，其中每个元素表示与其下标对应的原数组元素在原数组中出现的次数。如：arrayEnumerateUniq([10,20,10,30]) = [1,1,2,1]；

  • 也适用于参数大小相同的多个数组，这种情况下，对参数中所有数组的相同位置的元素进行统计次数，如：

    SELECT
      arrayEnumerateUniq(
        ['1','2','3','1','4','1'],
        ['2','3','4','2','3','2'],
        ['2','3','4','3','3','2']
      )
    
    [1,1,1,1,1,2]

• arrayPopBack(arr)

  • 删除数组的最后一项。

• arrayPopFront(arr)

  • 删除数组的第一项。

• arrayPushBack(arr, x)

  • 将元素x添加到数组的末尾；
  • 只能将数字添加到数字类型的数组中，字符串添加到字符串数组中。

• arrayPushFront(arr, x)

  • 将元素x添加到数组的开头；
  • 只能将数字添加到数字类型的数组中，字符串添加到字符串数组中。

• arrayResize(arr, size[, extender])

  • 更改数组的长度，将数组更改成长度为size的数组；
  • 如果size小于数组的原大小，则数组从右侧截断；
  • 如果size大于数组的原大小，则使用extender值或数组项的数据类型的默认值将数组扩展到右侧。

• arraySlice(arr, offset[, length])

  • 返回一个子数组，包含从指定位置的指定长度的元素；

  • offset表示数组的偏移。正值表示左侧的偏移量，负值表示右侧的缩进量，下标从 1 开始计算；

  • length表示子数组的长度，如果指定负值，则该函数返回[offset，array_length-length]，如果省略该值，则该函数返回[offset，the_end_of_array]。

  • 示例：

    SELECT
      arraySlice([1,2,3,4,5,6], -1)		# [6]
    
    SELECT
      arraySlice([1, 2, NULL, 4, 5], 2, 3)	# [2,NULL,4]

• arraySort([func,] arr, ...)

  • 对数组arr进行升序排序，如果指定了func函数，则排序顺序由func函数的调用结果决定。如果func接受多个参数，那么arraySort函数也将解析与func函数参数相同数量的数组参数。

  • NULL，NaN和Inf的排序顺序：

    SELECT
      arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf])
      
    [-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]

  • arraySort是高阶函数，可以将lambda函数作为第一个参数传递给它。在这种情况下，排序顺序由lambda函数的调用结果决定，示例：

    SELECT
      arraySort((x) -> -x, [1, 2, 3])
    
    [3,2,1]

    对于原数组的每个元素，lambda函数返回排序键，即[1 -> -1, 2 -> -2, 3 -> -3]。由于arraySort函数按升序对键进行排序，因此结果为[3,2,1]。所以，(x) -> -x lambda函数将排序设置为降序。
    lambda函数可以接受多个参数。在这种情况下，需要为arraySort传递与lambda参数个数相同的数组。函数使用第一个输入的数组中的元素组成返回结果，使用接下来传入的数组作为排序键。示例：

    SELECT
      arraySort((x, y) -> y, ['hello', 'world'], [2, 1])
    
    ["world","hello"]

    这里，在第二个数组[2, 1]中定义了第一个数组['hello'，'world']的相应元素的排序键，即['hello' -> 2，'world' -> 1]。 由于lambda函数中没有使用x，因此源数组中的实际值不会影响结果的顺序。所以，'world'将是结果中的第一个元素，'hello'将是结果中的第二个元素。其他示例：

    SELECT
      arraySort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a'])	# [2,1,0]
    
    SELECT
      arraySort((x, y) -> - y, [0, 1, 2], [1, 2, 3])	# [2,1,0]

• arrayReverseSort([func,] arr, ...)

  • 以降序对arr数组的元素进行排序。如果指定了func函数，则排序顺序由func函数的调用结果决定。如果func接受多个参数，那么arrayReverseSort函数也将解析与func函数参数相同数量的数组作为参数。具体用法同arraySort一样。

• arrayUniq(arr, ...)

  • 如果传递一个参数，则计算数组中不同元素的数量，如果传递了多个参数，则它计算多个数组中相应位置的不同元素元组的数量；
  • 如果要获取数组中唯一项的列表，可以使用arrayReduce('groupUniqArray'，arr)。

• arrayJoin(arr)

  • 行转列，对数组进行展开操作。示例：

    SELECT
      arrayJoin([1,2,3])
    
    1
    2
    3

• arrayDifference(arr)

  • 计算相邻数组元素之间的差异。返回一个数组，其中第一个元素为0，第二个是arr[1]-arr[0]之差等。返回的数组中元素的类型由减法的类型推断规则确定（例如UInt8-UInt8=Int16）。示例：

    SELECT
      arrayDifference([1, 3, 9, -3])
    
    [0,2,6,-12]

• arrayDistinct(arr)

  • 返回一个包含所有数组中不同元素的数组。示例：

    SELECT
      arrayDistinct([1, 2, 2, 3, 1])
    
    [1,2,3]

• arrayEnumerateDense(arr)

  • 返回与源数组大小相同的数组，指示每个元素首次出现在源数组中的位置。示例：

    SELECT
      arrayEnumerateDense([10, 20, 10, 30])
    
    [1,2,1,3]

• arrayIntersect(arr, ...)

  • 返回所有数组元素的交集。示例：

    SELECT
      arrayIntersect([1, 2], [1, 3], [1, 4])
    
    [1]

• arrayReduce(agg_func, arr1, arr2, ..., arrN)

  • 将聚合函数应用于数组元素并返回其结果。聚合函数的名称以单引号'max'、'sum'中的字符串形式传递，使用带参数的聚合函数时，参数在括号中的函数名称后写明，如：'uniqUpTo(6)'。

    SELECT
      arrayReduce('max', [1, 2, 3])		# 3
    
    SELECT
      arrayReduce('maxIf', [3, 5], [1, 0])	# 3
    
    SELECT
      arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])	# 4

• arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN)

  • 将聚合函数应用于给定范围内的数组元素，并返回一个包含与每个范围对应的结果的数组。该函数将返回与多个arrayReduce(agg_func,arraySlice(arr1,index,length),...)相同的结果；

  • ranges指要聚合的范围应该是元组为元素的数组，其中包含每个索引和长度范围，示例：

    SELECT
      arrayReduceInRanges(
        'sum',
        [(1, 5), (2, 3), (3, 4), (4, 4)],
        [1000000, 200000, 30000, 4000, 500, 60, 7]
      )
    
    [1234500,234000,34560,4567]

• arrayReverse(arr)

  • 返回一个与原始数组大小相同、元素相反的数组，示例：

    SELECT
      arrayReverse([1, 2, 3])
    
    [3,2,1]

• arrayFlatten(arr, ...)

  • 将嵌套的数组展平，适用于任何深度的嵌套数组，不会更改已经展平的数组，示例：

    SELECT
      flatten([[[1]], [[2], [3]]])
    
    [1,2,3]

• arrayCompact(arr)

  • 从数组中删除连续的重复元素。结果值的顺序由源数组中的顺序决定，示例：

    SELECT
      arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])
    
    [1,nan,2,3]

• arrayZip(arr1, arr2, ..., arrN)

  • 将多个数组组合成一个数组，返回一个将原数组中的元素分组为元组的数组。元组中的数据类型与输入数组的类型相同，并且与传递数组的顺序相同，示例：

    SELECT
      arrayZip(['a', 'b', 'c'], [5, 2, 1])
    
    [('a',5),('b',2),('c',1)]

• arrayMap(func, arr1, ...)

  • 将从func函数的原始应用中获得的数组返回给arr数组中的每个元素，示例：

    SELECT
      arrayMap(x -> (x + 2), [1, 2, 3])
    
    [3,4,5]

    SELECT
      arrayMap(
        (x, y, z) -> (x, y, z),
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
      )
    
    [(1,4,7),(2,5,8),(3,6,9)]

• arrayFilter(func, arr1, ...)

  • 返回一个仅包含arr1中的元素的数组，其中func返回的值不是 0，示例：

    SELECT
      arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World'])
    
    ['abc World']

    SELECT
      arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr
      )
    
    [2]

• arrayFill(func, arr1, ...)

  • 从第一个元素到最后一个元素扫描arr1，如果func返回 0，则用arr1[i-1]替换arr1[i]。arr1的第一个元素不会被替换，示例：

    SELECT
      arrayFill(
        x -> not isNull(x),
        [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]
      )
    
    [1,1,3,11,12,12,12,5,6,14,14,14]

• arrayReverseFill(func, arr1, ...)

  • 从最后一个元素到第一个元素扫描arr1，如果func返回 0，则用arr1[i+1]替换arr1[i]。arr1的最后一个元素不会被替换，示例：

    SELECT
      arrayReverseFill(
        x -> not isNull(x),
        [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]
      )
    
    [1,3,3,11,12,5,5,5,6,14,NULL,NULL]

• arraySplit(func, arr1, ...)

  • 将arr1拆分为多个数组。当func返回 0 以外的值时，数组将在元素的左侧拆分。数组不会在第一个元素之前被拆分，示例：

    SELECT
      arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0])
    
    [[1,2,3],[4,5]]

• arrayReverseSplit(func, arr1, ...)

  • 将arr1拆分为多个数组。当func返回 0 以外的值时，数组将在元素的右侧拆分，数组不会在最后一个元素之后被拆分。

    SELECT
      arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0])
    
    [[1],[2,3,4],[5]]

• arrayMin([func,] arr)

  • 返回数组中最小的元素，示例：

    SELECT
      arrayMin([1, 2, 4])	# 1
    
    SELECT
      arrayMin(x -> (- x), [1, 2, 4])	# -4

• arrayMax([func,] arr)

  • 返回数组中最大的元素，示例：

    SELECT
      arrayMax([1, 2, 4])	# 4
    
    SELECT
      arrayMax(x -> (- x), [1, 2, 4])	# -1

• arraySum([func,] arr)

  • 返回数组中元素的总和，示例：

    SELECT
      arraySum([2, 3])	# 5
    
    SELECT
      arraySum(x -> x * x, [2, 3])	# 13

• arrayAvg([func,] arr)

  • 返回数组中元素的平均值，示例：

    SELECT
      arrayAvg([1, 2, 4])	# 2.3333333333333335
    
    SELECT
      arrayAvg(x -> (x * x), [2, 4])	# 10

• arrayCumSum([func,] arr1, ...)

  • 返回源数组中元素的部分和的数组（运行总和）。如果指定了func函数，则数组元素的值在求和之前由该函数转换，示例：

    SELECT
      arrayCumSum([1, 2, 1, 8])
    
    [1,3,4,12]

• arrayCumSumNonNegative(arr)

  • 与arrayCumSum相同，返回数组中元素的部分和的数组（运行总和），区别是当返回值包含小于零的值时，将该值替换为零，并以零参数执行后续计算。示例：

    SELECT
      arrayCumSumNonNegative([1, 1, -4, 1])
    
    [1,2,0,1]

• arrayProduct(arr)

  • 将一个数组中的元素相乘。示例：

    SELECT
      arrayProduct([1,2,3,4,5,6])
    
    720

5. 时间日期函数

• timeZone()

  • 返回服务器的时区。 如果它在分布式表的上下文中执行，那么它会生成一个普通列，其中包含与每个分片相关的值。否则它会产生一个常数值。

• toTimeZone(value, timezone)

  • 将Date或DateTime转换为指定的时区。 时区是Date/DateTime类型的属性。 表字段或结果集的列的内部值（秒数）不会更改，列的类型会更改，并且其字符串表示形式也会相应更改。

• timeZoneOf(value)

  • 返回DateTime或者DateTime64数据类型的时区名称。value指类型和时间，类型为DateTime或者DateTime64。

• toYear

  • 将Date或DateTime转换为包含年份编号（AD）的UInt16类型的数字。

• toQuarter

  • 将Date或DateTime转换为包含季度编号的UInt8类型的数字。

• toMonth

  • 将Date或DateTime转换为包含月份编号（1-12）的UInt8类型的数字。

• toDayOfYear

  • 将Date或DateTime转换为包含一年中的某一天编号的UInt16（1-366）类型的数字。

• toDayOfMonth

  • 将Date或DateTime转换为包含一月中的某一天编号的UInt8（1-31）类型的数字。

• toDayOfWeek

  • 将Date或DateTime转换为包含一周中的某一天编号的UInt8（周一是 1，周日是 7）类型的数字。

• toHour

  • 将DateTime转换为包含 24 小时制（0-23）小时数的UInt8数字。

• toMinute

  • 将DateTime转换为包含一小时中分钟数（0-59）的UInt8数字。

• toSecond

  • 将DateTime转换为包含一分钟中秒数（0-59）的UInt8数字， 闰秒不计算在内。

• toUnixTimestamp

  • toUnixTimestamp(datetime)：将值转换为UInt32类型的 Unix 时间戳数字；
  • toUnixTimestamp(str, [timezone])：根据时区将输入字符串转换为日期时间，并返回相应的 Unix 时间戳。

• toStartOfYear

  • 将Date或DateTime向前取整到本年的第一天， 返回Date类型。

• toStartOfISOYear

  • 将Date或DateTime向前取整到 ISO 本年的第一天， 返回Date类型。

• toStartOfQuarter

  • 将Date或DateTime向前取整到本季度的第一天， 返回Date类型。

• toStartOfMonth

  • 将Date或DateTime向前取整到本月的第一天， 返回Date类型。

• toMonday

  • 将Date或DateTime向前取整到本周的星期一， 返回Date类型。

• toStartOfWeek(t [, mode])

  • 按mode将Date或DateTime向前取整到最近的星期日或星期一，返回Date类型。 mode参数的工作方式与toWeek()的mode参数完全相同，mode默认为 0。

• toStartOfDay

  • 将DateTime向前取整到今天的开始。

• toStartOfHour

  • 将DateTime向前取整到当前小时的开始。

• toStartOfMinute

  • 将DateTime向前取整到当前分钟的开始。

• toStartOfSecond(value [, timezone])

  • 将DateTime向前取整到当前秒数的开始。

• toStartOfFiveMinutes

  • 将DateTime以五分钟为单位向前取整到最接近的时间点。

• toStartOfFifteenMinutes

  • 将DateTime以十五分钟为单位向前取整到最接近的时间点。

• toStartOfInterval(time_or_data, 间隔x单位 [, time_zone])

  • 这是名为toStartOf*的所有函数的通用函数。
  • toStartOfInterval(t, INTERVAL 1 year)返回与toStartOfYear(t)相同的结果；
  • toStartOfInterval(t, INTERVAL 1 month)返回与toStartOfMonth(t)相同的结果；
  • toStartOfInterval(t, INTERVAL 1 day)返回与toStartOfDay(t)相同的结果；
  • toStartOfInterval(t, INTERVAL 15 minute)返回与toStartOfFifteenMinutes(t)相同的结果。

• toTime

  • 将DateTime中的日期转换为一个固定的日期，同时保留时间部分。

• toRelativeYearNum

  • 将Date或DateTime转换为年份的编号，从过去的某个固定时间点开始。

• toRelativeQuarterNum

  • 将Date或DateTime转换为季度的数字，从过去的某个固定时间点开始。

• toRelativeMonthNum

  • 将Date或DateTime转换为月份的编号，从过去的某个固定时间点开始。

• toRelativeWeekNum

  • 将Date或DateTime转换为星期数，从过去的某个固定时间点开始。

• toRelativeDayNum

  • 将Date或DateTime转换为当天的编号，从过去的某个固定时间点开始。

• toRelativeHourNum

  • 将DateTime转换为小时数，从过去的某个固定时间点开始。

• toRelativeMinuteNum

  • 将DateTime转换为分钟数，从过去的某个固定时间点开始。

• toRelativeSecondNum

  • 将DateTime转换为秒数，从过去的某个固定时间点开始。

• toISOYear

  • 将Date或DateTime转换为包含 ISO 年份的UInt16类型的编号。

• toISOWeek

  • 将Date或DateTime转换为包含 ISO 周数的UInt8类型的编号。

• toWeek(date [, mode][, Timezone])

  • 返回Date或DateTime的周数。两个参数形式可以指定星期是从星期日还是星期一开始，以及返回值应在 0 到 53 还是从 1 到 53 的范围内。如果省略了mode参数，则默认值为 0。 toISOWeek()是一个兼容函数，等效于toWeek(date,3)。

  • 如果包含 1 月 1 日的一周在后一年度中有 4 天或更多天，则为第 1 周，否则它是上一年的最后一周，下周是第 1 周。

  • 下表是mode参数的工作方式：

    Mode	First day of week	Range	Week 1 is the first week ...
    0	Sunday	0 - 53	with a Sunday in this year
    1	Monday	0 - 53	with 4 or more days this year
    2	Sunday	1 - 53	with a Sunday in this year
    3	Monday	1 - 53	with 4 or more days this year
    4	Sunday	0 - 53	with 4 or more days this year
    5	Monday	0 - 53	with a Monday in this year
    6	Sunday	1 - 53	with 4 or more days this year
    7	Monday	1 - 53	with a Monday in this year
    8	Sunday	1 - 53	contains January 1
    9	Monday	1 - 53	contains January 1

• toYearWeek(date [, mode])

  • 返回Date的年和周。 结果中的年份可能因为Date为该年份的第一周和最后一周导致Date的年份不同。mode参数的工作方式与toWeek()的mode参数完全相同，默认为 0；
  • toISOYear()是一个兼容函数，等效于intDiv(toYearWeek(date,3),100)。

• date_trunc(unit, value [, timezone])

  • 将Date或DateTime按指定的单位向前取整到最接近的时间点；
  • unit可选值：second、minute、hour、day、week、month、quarter、year。

• date_add(unit, value, date)

  • 将时间间隔或日期间隔添加到提供的日期或带时间的日期。

  • unit同date_trunc()一样，对应value的时间单位，示例：

    SELECT
      date_add(YEAR, 3, toDate('2018-01-01'))
    
    2021-01-01

• date_diff('unit', startdate, enddate, [timezone])

  • 返回两个日期或具有时间值的日期之间的差值；
  • unit对应value的时间单位，类型为String，可选值：microsecond、millisecond、second、minute、hour、day、week、month、quarter、year。

• date_sub(unit, value, date)

  • 从提供的日期或带时间的日期中减去时间间隔或日期间隔；

  • unit同date_trunc()一样，对应value的时间单位，示例：

    SELECT
      date_sub(YEAR, 3, toDate('2018-01-01'))
    
    2015-01-01

• timestamp_add(date, INTERVAL value unit)

  • 将指定的时间值与提供的日期或日期时间值相加；

  • unit同date_trunc()一样，对应value的时间单位，类型为String，示例：

    select
      timestamp_add(toDate('2018-01-01'), INTERVAL 3 MONTH)
    
    2018-04-01

• timestamp_sub(unit, value, date)

  • 从提供的日期或带时间的日期中减去时间间隔；

  • unit同date_trunc()一样，对应value的时间单位，类型为String，示例：

    select
      timestamp_sub(MONTH, 5, toDateTime('2018-12-18 01:02:03'))
    
    2018-07-18 01:02:03

• now([timezone])

  • 返回当前日期和时间，可选参数timezone指定时区。

• today

  • 不接受任何参数并在请求执行时的某一刻返回当前日期（Date）， 其功能与toDate(now())相同。

• yesterday

  • 不接受任何参数并在请求执行时的某一刻返回昨天日期（Date）， 其功能与today()-1相同。

• toYYYYMM

  • 将Date或DateTime转换为包含年份和月份编号的UInt32类型的数字（YYYY*100+MM）。

• toYYYYMMDD

  • 将Date或DateTime转换为包含年份和月份编号的UInt32类型的数字（YYYY*10000+MM*100+DD）。

• toYYYYMMDDhhmmss

  • 将Date或DateTime转换为包含年份和月份编号的UInt64类型的数字（YYYY*10000000000+MM*100000000+DD*1000000+hh*10000+mm*100+ss）。

• addYears, addMonths, addWeeks, addDays, addHours, addMinutes, addSeconds, addQuarters

  • 函数将一段时间间隔添加到Date/DateTime，然后返回Date/DateTime，示例：

    WITH
        toDate('2018-01-01') AS date,
        toDateTime('2018-01-01 00:00:00') AS date_time
    SELECT
        addYears(date, 1) AS add_years_with_date,
        addYears(date_time, 1) AS add_years_with_date_time
    
    ┌─add_years_with_date─┬─add_years_with_date_time─┐
    │          2019-01-01 │      2019-01-01 00:00:00 │
    └─────────────────────┴──────────────────────────┘

• subtractYears,subtractMonths,subtractWeeks,subtractDays,subtractours,subtractMinutes,subtractSeconds,subtractQuarters

  • 函数将Date/DateTime减去一段时间间隔，然后返回Date/DateTime，示例：

    WITH
        toDate('2019-01-01') AS date,
        toDateTime('2019-01-01 00:00:00') AS date_time
    SELECT
        subtractYears(date, 1) AS subtract_years_with_date,
        subtractYears(date_time, 1) AS subtract_years_with_date_time
    
    ┌─subtract_years_with_date─┬─subtract_years_with_date_time─┐
    │               2018-01-01 │           2018-01-01 00:00:00 │
    └──────────────────────────┴───────────────────────────────┘

• timeSlots(StartTime, Duration,[, Size])

  • 它返回一个时间数组，其中包括从从StartTime开始到StartTime+Duration秒内的所有符合size（以秒为单位）步长的时间点。其中size是一个可选参数，默认为 1800。 例如，timeSlots(toDateTime('2012-01-01 12:20:00'), 600) = [toDateTime('2012-01-01 12:00:00'), toDateTime('2012-01-01 12:30:00')]，这对于搜索在相应会话中综合浏览量是非常有用的。

• formatDateTime(Time, Format[, Timezone])

  • 函数根据给定的格式字符串来格式化时间。格式字符串必须是常量表达式，例如：单个结果列不能有多种格式字符串。

  • 支持的格式修饰符：

    修饰符	描述	示例
    %C	年除以100并截断为整数(00-99)	20
    %d	月中的一天，零填充（01-31)	02
    %D	短MM/DD/YY日期，相当于%m/%d/%y	01/02/2018
    %e	月中的一天，空格填充（ 1-31)	2
    %F	短YYYY-MM-DD日期，相当于%Y-%m-%d	2018-01-02
    %G	ISO周号的四位数年份格式， 从基于周的年份由ISO 8601定义 标准计算得出，通常仅对％V有用	2018
    %g	两位数的年份格式，与ISO 8601一致，四位数表示法的缩写	18
    %H	24小时格式（00-23)	22
    %I	12小时格式（01-12)	10
    %j	一年中的一天 (001-366)	002
    %m	月份为十进制数（01-12)	01
    %M	分钟(00-59)	33
    %n	换行符(")
    %p	AM或PM指定	PM
    %Q	季度（1-4)	1
    %R	24小时HH:MM时间，相当于%H:%M	22:33
    %S	秒 (00-59)	44
    %t	水平制表符(')
    %T	ISO8601时间格式(HH:MM:SS)，相当于%H:%M:%S	22:33:44
    %u	ISO8601工作日为数字，星期一为1(1-7)	2
    %V	ISO8601周编号(01-53)	01
    %w	工作日为十进制数，周日为0(0-6)	2
    %y	年份，最后两位数字（00-99)	18
    %Y	年	2018
    %%	%符号	%

  • 示例：

    SELECT
      formatDateTime(toDate('2010-01-04'), '%g')
    
    10

• dateName(date_part, date)

  • 返回日期的指定部分；

  • date_part类型为String，可为 'year', 'quarter', 'month', 'week', 'dayofyear', 'day', 'weekday', 'hour', 'minute', 'second'；

  • 示例：

    WITH toDateTime('2021-04-14 11:22:33') AS date_value
    SELECT
      dateName('year', date_value),
      dateName('month', date_value),
      dateName('day', date_value)
    
    ┌─dateName('year', date_value)─┬─dateName('month', date_value)─┬─dateName('day', date_value)─┐
    │ 2021                         │ April                         │ 14                          │
    └──────────────────────────────┴───────────────────────────────┴─────────────────────────────

• FROM_UNIXTIME

  • 当只有单个整数类型的参数时，它的作用与toDateTime相同，并返回DateTime类型，示例：

    SELECT
      FROM_UNIXTIME(423543535)
    
    1983-06-04 10:58:55

  • 当有两个参数时，第一个是整型或DateTime，第二个是常量格式字符串，它的作用与formatDateTime相同，并返回String类型，示例：

    SELECT
      FROM_UNIXTIME(1234334543, '%Y-%m-%d %R:%S')
    
    2009-02-11 14:42:23

6. 字典函数

• dictGetString('dict_name', 'attr_name', id)
  • 使用id键获取dict_name字典中attr_name属性的值。dict_name和attr_name是常量字符串。id必须是UInt64。 如果字典中没有id键，则返回字典描述中指定的默认值。
• dictGetTOrDefault('dict_name', 'attr_name', id, default)
  • 与dictGetString()函数相同，但默认值取自函数的最后一个参数。
• dictIsIn('dict_name', child_id, ancestor_id)
  • 对于dict_name分层字典，查找child_id键是否位于ancestor_id内（或匹配ancestor_id）。返回UInt8。
• dictGetHierarchy('dict_name', id)
  • 对于dict_name分层字典，返回从id开始并沿父元素链继续的字典键数组，返回 Array（UInt64）。
• dictHas('dict_name', id)
  • 检查字典是否存在指定的id。如果不存在，则返回 0，如果存在，则返回 1。

7. Nullable处理函数

• isNull(x)
  • x为一个非复合数据类型的值；
  • 如果为NULL返回 1，不为NULL返回 0。
• isNotNull(x)
  • 同isNull()函数作用相反。
• coalesce(x,...)
  • 检查从左到右是否传递了NULL参数并返回第一个非NULL参数；
  • 如果所有参数都是NULL则返回NULL。
• ifNull(x,alt)
  • 如果第一个参数为NULL，则返回第二个参数的值，否则返回第一个值。
• nullIf(x, y)
  • 如果参数相等，则返回NULL，x和y类型必须兼容，否则抛出异常；
  • 如果参数不相等，则返回x。
• assumeNotNull(x)
  • 将可为空类型的值转换为非Nullable类型的值；
  • 如果x不为NULL，返回x，如果x为NULL，则返回该类型的默认值。
• toNullable(x)
  • 将参数的类型转换为Nullable。

8. IP函数

• IPv4NumToString(num)

  • 接受一个UInt32（大端）表示的IPv4的地址，返回相应IPv4的字符串表现形式，格式为A.B.C.D（以点分割的十进制数字）。

• IPv4StringToNum(s)

  • 与IPv4NumToString函数相反。如果IPv4地址格式无效，则返回 0。

• IPv4NumToStringClassC(num)

  • 与IPv4NumToString类似，但使用xxx替换最后一个字节。

• IPv6NumToString(x)

  • 接受FixedString(16)类型的二进制格式的IPv6地址。以文本格式返回此地址的字符串。IPv6映射的IPv4地址以::ffff:111.222.33。例如：

    SELECT 
    	IPv6NumToString(toFixedString(unhex('2A0206B8000000000000000000000011'), 16)) AS addr
    
    2a02:6b8::11

• IPv6StringToNum(s)

  • 与IPv6NumToString相反。如果IPv6地址格式无效，则返回空字节字符串。 十六进制可以是大写的或小写的。

• IPv4ToIPv6(x)

  • 接受一个UInt32类型的IPv4地址，返回FixedString(16)类型的IPv6地址。例如：

    SELECT
    	IPv6NumToString(IPv4ToIPv6(IPv4StringToNum('192.168.0.1'))) AS addr
    
    ::ffff:192.168.0.1

• toIPv4(字符串)

  • IPv4StringToNum()的别名，它采用字符串形式的IPv4地址并返回IPv4类型的值，该二进制值等于IPv4StringToNum()返回的值。

• toIPv6(字符串)

  • IPv6StringToNum()的别名，它采用字符串形式的IPv6地址并返回IPv6类型的值，该二进制值等于IPv6StringToNum()返回的值。

9. 字符串拆分合并函数

• splitByChar(分隔符，s)
  • 将字符串以separator拆分成多个子串。separator必须为仅包含一个字符的字符串常量， 返回拆分后的子串的数组；
  • 如果分隔符出现在字符串的开头或结尾，或者如果有多个连续的分隔符，则将在对应位置填充空的子串。
• splitByString(分隔符，s)
  • 与splitByChar相同，但它使用多个字符的字符串作为分隔符。 该字符串必须为非空。
• arrayStringConcat(arr[,分隔符])
  • 使用separator将数组中列出的字符串拼接起来。separator是一个可选参数：一个常量字符串，默认情况下设置为空字符串。 返回拼接后的字符串。
• alphaTokens(s)

  • 从范围a-z和A-Z中选择连续字节的子字符串，返回子字符串数组；

  • 示例：

    SELECT
    	alphaTokens('abca1abc')
    
    ['abca','abc']

10. 字符串函数

• empty

  • 对于空字符串返回 1，对于非空字符串返回 0。 结果类型是UInt8。 如果字符串包含至少一个字节，则该字符串被视为非空字符串，即使这是一个空格或空字符。 该函数也适用于数组。

• notEmpty

  • 对于空字符串返回 0，对于非空字符串返回 1。 结果类型是UInt8。 该函数也适用于数组。

• length

  • 返回字符串的字节长度。 结果类型是UInt64。 该函数也适用于数组。

• lower, lcase

  • 将字符串中的ASCII转换为小写。

• upper, ucase

  • 将字符串中的ASCII转换为大写。

• reverse

  • 反转字符串。

• format(pattern, s0, s1, ...)

  • 使用常量字符串pattern格式化其他参数。pattern字符串中包含由大括号{}包围的替换字段。 未被包含在大括号中的任何内容都被视为文本内容，它将原样保留在返回值中。示例：

    SELECT
      format('{1} {0} {0}{1}{1}', 'World', 'Hello')
    
    Hello World WorldHelloHello

• concat(s1, s2, ...)

  • 将参数中的多个字符串拼接，不带分隔符。

• substring(s,offset,length), mid(s,offset,length), substr(s,offset,length)

  • 以字节为单位截取指定位置字符串，返回以offset位置为开头，长度为length的子串。offset从1开始（与标准 SQL 相同）。offset和length参数必须是常量。

• appendTrailingCharIfAbsent(s,c)

  • 如果s字符串非空并且末尾不包含c字符，则将c字符附加到末尾。

• endsWith(s,后缀)

  • 返回是否以指定的后缀结尾。如果字符串以指定的后缀结束，则返回 1，否则返回 0。

• startsWith(s，前缀)

  • 返回是否以指定的前缀开头。如果字符串以指定的前缀开头，则返回 1，否则返回 0。

• trimLeft(s)

  • 返回一个字符串，用于删除左侧的空白字符。

• trimRight(s)

  • 返回一个字符串，用于删除右侧的空白字符。

• trimBoth(s)

  • 返回一个字符串，用于删除任一侧的空白字符。

11. 字符串替换函数

• replaceOne(haystack, pattern, replacement)

  • 用replacement子串替换haystack中第一次出现的pattern子串（如果存在）。 pattern和replacement必须是常量。

• replaceAll(haystack, pattern, replacement), replace(haystack, pattern, replacement)

  • 用replacement子串替换haystack中出现的所有的pattern子串。

• replaceRegexpOne(haystack, pattern, replacement)

  • 使用pattern正则表达式的替换。 pattern可以是任意一个有效的re2正则表达式。 如果存在与pattern正则表达式匹配的匹配项，仅替换第一个匹配项。 模式pattern可以指定为replacement。此模式可以包含替代\0-\9。 替代\0包含了整个正则表达式。替代\1-\9对应于子模式编号。要在模板中使用反斜杠\，请使用\将其转义。 另外还请记住，字符串字面值（literal）需要额外的转义。

  • 示例：

    SELECT DISTINCT
        EventDate,
        replaceRegexpOne(toString(EventDate), '(\\d{4})-(\\d{2})-(\\d{2})', '\\2/\\3/\\1') AS res
    FROM test.hits
    LIMIT 7
    FORMAT TabSeparated
    
    2014-03-17      03/17/2014
    2014-03-18      03/18/2014
    2014-03-19      03/19/2014
    2014-03-20      03/20/2014
    2014-03-21      03/21/2014
    2014-03-22      03/22/2014
    2014-03-23      03/23/2014
    
    SELECT
    	replaceRegexpOne('Hello, World!', '.*', '\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0') AS res
    
    Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!

• replaceRegexpAll(haystack, pattern, replacement)

  • 与replaceRegexpOne相同，但会替换所有出现的匹配项。例如：

    SELECT
    	replaceRegexpAll('Hello, World!', '.', '\\0\\0') AS res
    
    HHeelllloo,,  WWoorrlldd!!

  • 另外，对于空子字符串，正则表达式只会进行一次替换。 示例：

    SELECT
    	replaceRegexpAll('Hello, World!', '^', 'here: ') AS res
    
    here: Hello, World!

12. 聚合函数

• count

• min

• max

• sum

• avg

• any

• argMin(arg, val)

  • 计算val最小值对应的arg值。 如果val最小值存在几个不同的arg值，输出遇到的第一个arg值；

  • 示例：

    ┌─user─────┬─salary─┐
    │ director │   5000 │
    │ manager  │   3000 │
    │ worker   │   1000 │
    └──────────┴────────┘
    
    SELECT
    	argMin(user, salary), argMin(tuple(user, salary), salary) FROM salary;
    
    ┌─argMin(user, salary)─┬─argMin(tuple(user, salary), salary)─┐
    │ worker               │ ('worker',1000)                     │
    └──────────────────────┴─────────────────────────────────────┘

• argMax(arg, val)

  • 计算val最大值对应的arg值。 如果val最大值存在几个不同的arg值，输出遇到的第一个值。

• groupArray(x)

  • 列转行。

参考文献

【1】https://clickhouse.com/docs/zh/sql-reference/functions