常用高阶函数
Clickhouse一共指定了二十多个函数为高阶函数，它们中的大部分都在高阶函数中列出。
由于文档更新原因，有些函数没列出来，而有些函数的文档有错误，这里全部都一一修正。
一. Array相关高阶函数。
arrayMap(func, arr1, ...)
arrayFilter(func, arr1, ...)
arrayFirst(func, arr1, ...)
arrayFirstIndex(func, arr1, ...)
arrayLast(func, arr1, ...)
arrayLastIndex(func, arr1, ...)
arrayFill(func, arr1, ...)
arrayReverseFill(func, arr1, ...)
arraySplit(func, arr1, ...)
arrayReverseSplit(func, arr1, ...)
arrayMin(func, arr)
arrayMax(func, arr)
arrayAvg(func, arr)
arrayCount([func,] arr1, ...)
arrayExists([func,] arr1, ...)
arrayAll([func,] arr1, ...)
arraySum([func,] arr1, ...)
arrayCumSum([func,] arr1, ...)
arrayCumSumNonNegative(arr)
arraySort([func,] arr1, ...)
arrayReverseSort([func,] arr1, ...)
二. Map相关高阶函数。
mapApply(func, map)
mapFilter(func, map)
mapExists(func, map)
mapAll(func map)
mapSort([func], map)
mapReverseSort([func], map)
这些函数之所以被定义为高阶，是因为它们可以接受Lambda表达式作为参数（func），例如：x -> 2 * x，或者str -> str != 'some string'。
注意：Clickhouse中数组Array和元组Tuple的索引/下标都是从1开始的。
一. Array相关高阶函数
1. arrayMap(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
按照Lambda表达式的要求返回新的数组。
对数组中每个元素+2。
:) SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as arr;
┌─arr─────┐
│ [3,4,5] │
└─────────┘从不同的数组创建元素元组。
:) SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) as arr;
┌─arr─────────────────┐
│ [(1,4),(2,5),(3,6)] │
└─────────────────────┘将ARRAY JOIN与arrayMap()函数结合起来。
:) CREATE TABLE array_join_arraymap
(
id UInt32,
money Decimal(16, 2),
createtime Datetime
) ENGINE = MergeTree()
ORDER BY id;
:) INSERT INTO array_join_arraymap VALUES
(1, 100, '2023-01-01 10:00:00'),
(1, 100, '2023-02-01 10:00:00'),
(1, 100, '2023-03-01 10:00:00'),
(1, 100, '2023-04-01 10:00:00'),
(1, 100, '2023-05-01 10:00:00'),
(1, 100, '2023-06-01 10:00:00'),
(1, 100, '2023-07-01 10:00:00'),
(1, 100, '2023-08-01 10:00:00'),
(1, 100, '2023-09-01 10:00:00'),
(1, 100, '2023-10-01 10:00:00'),
(1, 100, '2023-11-01 10:00:00'),
(1, 100, '2023-12-01 10:00:00'),
(1, 100, '2024-01-01 10:00:00'),
(1, 100, '2024-02-01 10:00:00'),
(1, 100, '2024-03-01 10:00:00'),
(1, 100, '2024-04-01 10:00:00'),
(1, 100, '2024-05-01 10:00:00'),
(1, 100, '2024-06-01 10:00:00'),
(1, 100, '2024-07-01 10:00:00'),
(1, 100, '2024-08-01 10:00:00'),
(1, 100, '2024-09-01 10:00:00'),
(1, 100, '2024-10-01 10:00:00'),
(1, 100, '2024-11-01 10:00:00'),
(1, 100, '2024-12-01 10:00:00');
┌─id─┬─money─┬──────────createtime─┐
│ 1 │ 100 │ 2023-01-01 10:00:00 │
│ 1 │ 100 │ 2023-02-01 10:00:00 │
│ 1 │ 100 │ 2023-03-01 10:00:00 │
│ 1 │ 100 │ 2023-04-01 10:00:00 │
│ 1 │ 100 │ 2023-05-01 10:00:00 │
│ 1 │ 100 │ 2023-06-01 10:00:00 │
│ 1 │ 100 │ 2023-07-01 10:00:00 │
│ 1 │ 100 │ 2023-08-01 10:00:00 │
│ 1 │ 100 │ 2023-09-01 10:00:00 │
│ 1 │ 100 │ 2023-10-01 10:00:00 │
│ 1 │ 100 │ 2023-11-01 10:00:00 │
│ 1 │ 100 │ 2023-12-01 10:00:00 │
│ 1 │ 100 │ 2024-01-01 10:00:00 │
│ 1 │ 100 │ 2024-02-01 10:00:00 │
│ 1 │ 100 │ 2024-03-01 10:00:00 │
│ 1 │ 100 │ 2024-04-01 10:00:00 │
│ 1 │ 100 │ 2024-05-01 10:00:00 │
│ 1 │ 100 │ 2024-06-01 10:00:00 │
│ 1 │ 100 │ 2024-07-01 10:00:00 │
│ 1 │ 100 │ 2024-08-01 10:00:00 │
│ 1 │ 100 │ 2024-09-01 10:00:00 │
│ 1 │ 100 │ 2024-10-01 10:00:00 │
│ 1 │ 100 │ 2024-11-01 10:00:00 │
│ 1 │ 100 │ 2024-12-01 10:00:00 │
└────┴───────┴─────────────────────┘求近12个月的金额，每个月的计算范围是截止到当前月的近12个月。
:) SELECT id, sum(money) AS money, toYear(mon) AS year, toMonth(mon) AS month
FROM array_join_arraymap
ARRAY JOIN arrayMap(x -> addMonths(createtime, x), range(0, 12)) AS mon
WHERE createtime BETWEEN toStartOfMonth(subtractMonths(toDate(now()), 23)) AND now()
AND mon BETWEEN toStartOfMonth(subtractMonths(toDate(now()), 11)) AND now()
GROUP BY id, year, month
ORDER BY year ASC, month ASC;
┌─id─┬─money─┬─year─┬─month─┐
│ 1 │ 700 │ 2023 │ 7 │
│ 1 │ 800 │ 2023 │ 8 │
│ 1 │ 900 │ 2023 │ 9 │
│ 1 │ 1000 │ 2023 │ 10 │
│ 1 │ 1100 │ 2023 │ 11 │
│ 1 │ 1200 │ 2023 │ 12 │
│ 1 │ 1200 │ 2024 │ 1 │
│ 1 │ 1200 │ 2024 │ 2 │
│ 1 │ 1200 │ 2024 │ 3 │
│ 1 │ 1200 │ 2024 │ 4 │
│ 1 │ 1200 │ 2024 │ 5 │
│ 1 │ 1200 │ 2024 │ 6 │
└────┴───────┴──────┴───────┘这里面，range(0，12)函数生成一个0~11的数组，而x代表数组的每个元素。
:) arrayMap(x -> addMonths(createtime, x), range(0, 12));arrayMap()让createtime依次去addMonths()，它被加了12个月，也就是恰好一整年的时间。
2. arrayFilter(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
按照Lambda表达式的要求过滤出满足指定条件的数组元素。
:) SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'New World']) AS res;
┌─res───────────┐
│ ['New World'] │
└───────────────┘
:) SELECT arrayFilter
(
(i, x) -> x LIKE '%World%', arrayEnumerate(arr), ['Hello', 'New World'] AS arr
)
AS res;
┌─res───────────┐
│ ['New World'] │
└───────────────┘
:) SELECT arrayFilter(x -> x > 1, [1, 2, 3]) AS res;
┌─res───┐
│ [2,3] │
└─────┘3. arrayFirst(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
按照Lambda表达式的要求返回第一个满足条件的数组元素。
:) SELECT arrayFirst(x -> x > 1, [1, 3, 2, -4]) AS res;
┌─res─┐
│ 3 │
└─────┘4. arrayFirstIndex(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
和arrayFirst()类似，但它返回第一个满足Lambda表达式条件的数组元素的下标。
:) SELECT arrayFirstIndex(x -> x > 1, [1, 3, 2, -4]) AS res;
┌─res─┐
│ 2 │
└─────┘5. arrayLast(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
返回数组中的最后一个元素，其中Lambda表达式需要返回一个判断条件而非一个数字值。
:) SELECT arrayLast(x -> x > 1, [1, 3, 5, -4]) AS res;
┌─res─┐
│ 5 │
└─────┘
:) SELECT arrayLast(x -> x LIKE 'Click%', ['Click1', 'hello', 'world']) AS res;
┌─res────┐
│ Click1│
└────────┘6. arrayLastIndex(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
返回数组中的最后一个元素的下下标，其中Lambda表达式需要返回一个判断条件而非一个数字值。
:) SELECT arrayLastIndex(x -> x > 1, [1, 3, 5, -4]) AS res;
┌─res─┐
│ 3 │
└─────┘
:) SELECT arrayLastIndex(x -> x LIKE 'Click%', ['Click1', 'hello', 'world']) AS res;
┌─res──┐
│ 1 │
└──────┘7. arrayFill(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
按照Lambda表达式的要求，从第一个元素扫描到最后一个元素。如果Lambda表达式返回0（即false），则用arr1[i - 1]替换arr1[i]，且数组的第一个元素不会被替换。
:) SELECT arrayFill(x -> isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res;
┌─res────────────────────────────────────────────────────────┐
│ [1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL] │
└────────────────────────────────────────────────────────────┘8. arrayReverseFill(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
和arrayFill()类似，但从最后一个元素开始倒着扫描到第一个元素。如果Lambda表达式返回1（即true），则用arr1[i + 1]替换arr1[i]，且数组的最后一个元素不会被替换。
:) SELECT arrayReverseFill(x -> isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res;
┌─res────────────────────────────────┐
│ [1,3,3,11,12,5,5,5,6,14,NULL,NULL] │
└────────────────────────────────────┘9. arraySplit(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
将arr1拆分为多个数组。当Lambda表达式返回0以外的值时，数组将在元素的左侧拆分，且数组不会在第一个元素之前被拆分。
:) SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res;
┌─res─────────────┐
│ [[1,2,3],[4,5]] │
└─────────────────┘
:) SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 1, 0, 1, 0]) AS res;
┌─res─────────────────┐
│ [[1],[2,3],[4],[5]] │
└─────────────────────┘10. arrayReverseSplit(func, arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
和arrayReverseSplit类似，但当Lambda表达式返回0以外的值时，数组将在元素的右侧拆分，且数组不会在最后一个元素之后被拆分。
:) SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res;
┌─res───────────────┐
│ [[1],[2,3,4],[5]] │
└───────────────────┘
:) SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 1, 0, 1, 0]) AS res;
┌─res─────────────────┐
│ [[1],[2],[3,4],[5]] │
└─────────────────────┘除了前面这十个函数以外，其余的高阶函数都可以省略Lambda表达式参数。
11. arrayMin([func], arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
返回源数组中的最小元素。
如果有Lambda表达式，则返回满足条件的最小元素。
:) SELECT arrayMin(x -> x + 1, [1, 2, 3, 4, 5]) AS res;
┌─res─┐
│ 2 │
└─────┘
:) SELECT arrayMin([1, 2, 3, 4, 5]) AS res;
┌─res─┐
│ 1 │
└─────┘12. arrayMax([func], arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
和arrayMin类似，但它返回源数组中的最大元素。
如果有Lambda表达式，则返回满足条件的最大元素。
:) SELECT arrayMax(x -> x + 1, [1, 2, 3, 4, 5]) AS res;
┌─res─┐
│ 6 │
└─────┘
:) SELECT arrayMax([1, 2, 3, 4, 5]) AS res;
┌─res─┐
│ 5 │
└─────┘13. arrayAvg([func], arr1, ...)
参数1：func表示要执行操作的Lambda表达式。
参数2：arr1表示被执行的目标数组。
返回源数组中元素的平均值。
如果有Lambda表达式，则返回满足条件的元素平均值。
:) SELECT arrayAvg(x -> x + 1, [1, 2, 3, 4, 4]) AS res;
┌─res───┐
│ 3.8 │
└───────┘
:) SELECT arrayAvg([1, 2, 7]) AS res;
┌────────────────res─┐
│ 3.3333333333333335 │
└────────────────────┘14. arrayCount([func,] arr1, ...)
如果有Lambda表达式参数，那么会统计数组中满足Lambda表达式条件的元素数量（此时数组元素的类型不必是UInt8）。
如果没有Lambda表达式参数：
数组元素必须是
UInt8类型，否则抛出异常。返回数组中非零元素的数量。
:) SELECT arrayCount(x -> x > 1, [1, 2, 3, -4]) AS res;
┌─res─┐
│ 2 │
└─────┘
:) SELECT arrayCount([0, 1, 2, 3, 4]) AS res;
┌─res─┐
│ 4 │
└─────┘15. arrayExists([func,] arr1, ...)
如果有Lambda表达式参数，那么会判断数组中是否存在满足Lambda表达式条件的元素（此时数组元素的类型不必是UInt8）。
如果没有Lambda表达式参数：
数组元素必须是
UInt8类型，否则抛出异常。判断数组中是否存在非零元素，存在则返回1（即true），否则返回0（即false）。
:) SELECT arrayExists([0]) AS res;
┌─res─┐
│ 0 │
└─────┘
:) SELECT arrayExists([0, 1]) AS res;
┌─res─┐
│ 1 │
└─────┘
:) SELECT arrayExists(x -> x > 0, [-1, 0, 1]) AS res;
┌─res─┐
│ 1 │
└─────┘
:) SELECT arrayExists(x -> x LIKE 'Clickhouse%', ['Clickhouse123', 'database', 'MySQL']) AS res;
┌─res─┐
│ 1 │
└─────┘16. arrayAll([func,] arr1, ...)
如果有Lambda表达式参数，那么会判断数组中的所有元素是否都满足Lambda表达式的条件（此时数组元素的类型不必是UInt8）。
如果没有Lambda表达式参数：
数组元素必须是
UInt8类型，否则抛出异常。判断数组中的所有元素是否都为非零元素，是则返回1（即true），否则返回0（即false）。
:) SELECT arrayAll(x -> x >= 1, [2, 1]) AS res;
┌─res─┐
│ 1 │
└─────┘
:) SELECT arrayAll([2, 1]) AS res;
┌─res─┐
│ 1 │
└─────┘
:) SELECT arrayAll([2, 0]) AS res;
┌─res─┐
│ 0 │
└─────┘17. arraySum([func,] arr1, ...)
如果有Lambda表达式参数，那么会先筛选出数组中满足Lambda表达式条件的元素（此时数组元素的类型不必是UInt8）。
- 如果是非数字类型，则仅做条件判断，满足条件则返回1（即true），否则返回0（即false）。
:) SELECT arraySum(x -> x LIKE 'Clickhouse%', ['2', '2']) AS res;
┌─res─┐
│ 0 │
└─────┘- 如果是数字类型，又分为两种情况。
:) SELECT arraySum(x -> x + 1, [1, 2, 3, 4]) AS res;
┌─res─┐
│ 14 │
└─────┘
:) SELECT arraySum(x -> x >= 1, [0, 3]) AS res;
┌─res─┐
│ 1 │
└─────┘如果没有Lambda表达式参数，则数组元素必须为数字类型（但不必是UInt8），且对其中所有的元素求和。
:) SELECT arraySum([-1, 3]) AS res;
┌─res─┐
│ 2 │
└─────┘18. arrayCumSum([func,] arr1, ...)
如果有Lambda表达式参数，则会按照Lambda表达式的条件，计算并返回结果数组。
arrayCumSum()计算并返回结果的方式为：[1, 2, 3, 4] => arrayCumSum => [1, 3, 6, 10]
它会把前一个元素和后一个元素相加，将结果作为后一个元素的新值。
:) SELECT arrayCumSum(x -> x + 1, [1, 3, 2, -4]) AS res;
┌─res───────┐
│ [2,6,9,6] │
└───────────┘
:) SELECT arrayCumSum(x -> x >= 2, [1, 3, 2, -4]) AS res;
┌─res───────┐
│ [0,1,2,2] │
└───────────┘19. arrayCumSumNonNegative(arr)
这个函数不接受Lambda表达式参数，它和arrayCumSum()的功能相同，但当返回值包含小于零的值时，该值替换为零，后续计算使用零继续计算。
:) SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res;
┌─res───────┐
│ [1,2,0,1] │
└───────────┘20. arraySort([func,] arr1, ...)
如果有Lambda表达式参数，则会按照Lambda表达式的条件返回排序结果，否则返回升序数组。
如果有第二个数组参数，那么它定义的是第一个数组的排序键。
:) SELECT arraySort(x -> x + 1, [3, 2, -4, 1]) AS res;
┌─res────────┐
│ [-4,1,2,3] │
└────────────┘
:) SELECT arraySort(x -> x > 1, [3, 2, -4, 1]) AS res;
┌─res────────┐
│ [-4,1,3,2] │
└────────────┘
:) SELECT arraySort([3, 2, -4, 1]) AS res;
┌─res────────┐
│ [-4,1,2,3] │
└────────────┘
:) SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) AS res;
┌─res────────────────┐
│ ['world', 'hello'] │
└────────────────────┘
:) SELECT arraySort([1, nan, 2, NULL, 3, nan, 4, NULL]) AS res;
┌─res─────────────────────────┐
│ [1,2,3,4,nan,nan,NULL,NULL] │
└─────────────────────────────┘
:) arraySort((x) -> -x, [1, 2, 3]) as res;
┌─res─────┐
│ [3,2,1] │
└─────────┘
:) SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res;
┌─res─────┐
│ [2,1,0] │
└─────────┘21. arrayReverseSort([func,] arr1, ...)
arrayReverseSort()和arraySort()的功能完全相同，只不过返回的是降序的数组。
如果有第二个数组参数，那么它定义的是第一个数组的排序键。
:) SELECT arrayReverseSort(x -> x + 1, [3, 2, -4, 1]) AS res;
┌─res────────┐
│ [3,2,1,-4] │
└────────────┘
:) SELECT arrayReverseSort(x -> x > 1, [3, 2, -4, 1]) AS res;
┌─res────────┐
│ [3,2,-4,1] │
└────────────┘
:) SELECT arrayReverseSort([3, 2, -4, 1]) AS res;
┌─res────────┐
│ [3,2,1,-4] │
└────────────┘
:) SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) AS res;
┌─res────────────────┐
│ ['hello', 'world'] │
└────────────────────┘
:) SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, 4, NULL]) AS res;
┌─res─────────────────────────┐
│ [4,3,2,1,nan,nan,NULL,NULL] │
└─────────────────────────────┘
:) SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
┌─res───────────────────────────────────┐
│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────┘
:) SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
┌─res─────┐
│ [5,3,4] │
└─────────┘22. arrayJoin(arr)
除此上面这些之外，还有一个用的非常多的数组函数arrayJoin(arr)。它虽然没有被归类到高阶函数，但由于它经常和ARRAY JOIN子句、arrayMap(func, arr1, ...)等函数搭配使用的关系，所以它照道理也应该算作是这些高阶函数的延申。
arrayJoin(arr)将数组中的元素展开为一行行的数据，方便其他函数或查询方法处理。
:) SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src;
┌─dst─┬─\'Hello\'─┬─src─────┐
│ 1 │ Hello │ [1,2,3] │
│ 2 │ Hello │ [1,2,3] │
│ 3 │ Hello │ [1,2,3] │
└─────┴───────────┴─────────┘二. Map相关高阶函数
1. mapApply(func, map)
参数1：func表示要执行操作的Lambda表达式。
参数2：map表示被执行的目标键值对。
通过对每个元素应用Lambda表达式，从原始map中获得的新的map。
:) SELECT mapApply((k, v) -> (k, v * 10), oldmap) AS res
FROM
(
SELECT map('key1', number, 'key2', number * 2) AS oldmap
FROM numbers(3)
);
┌─res───────────────────┐
│ {'key1':0,'key2':0} │
│ {'key1':10,'key2':20} │
│ {'key1':20,'key2':40} │
└───────────────────────┘2. mapFilter(func, map)
参数1：func表示要执行操作的Lambda表达式。
参数2：map表示被执行的目标键值对。
通过Lambda表达式来过滤map中的每一个元素，并且仅返回满足Lambda表达式的map。
:) SELECT mapFilter((k, v) -> ((v % 2) == 0), oldmap) AS res;
FROM
(
SELECT map('key1', number, 'key2', number * 2) AS oldmap
FROM numbers(3)
)
┌─res─────────────────┐
│ {'key1':0,'key2':0} │
│ {'key2':2} │
│ {'key1':2,'key2':4} │
└─────────────────────┘3. mapExists(func, map)
参数1：func表示要执行操作的Lambda表达式。
参数2：map表示被执行的目标键值对。
如果map中存在满足Lambda表达式条件的键值对，则返回1，否则返回0。
:) SELECT mapExists((k, v) -> (v = 1), map('k1', 1, 'k2', 2)) AS res;
┌─res─┐
│ 1 │
└─────┘
:) SELECT mapExists((k, v) -> (v > 3), map('k1', 1, 'k2', 2)) AS res;
┌─res─┐
│ 0 │
└─────┘4. mapAll(func, map)
参数1：func表示要执行操作的Lambda表达式。
参数2：map表示被执行的目标键值对。
如果map中每一个键值对都满足Lambda表达式的条件则返回1，否则返回0。
:) SELECT mapAll((k, v) -> (v = 1), map('k1', 1, 'k2', 2)) AS res;
┌─res─┐
│ 0 │
└─────┘
:) SELECT mapAll((k, v) -> (v >= 1), map('k1', 1, 'k2', 2)) AS res;
┌─res─┐
│ 1 │
└─────┘5. mapSort([func], map)
参数1：func表示要执行操作的Lambda表达式。
参数2：map表示被执行的目标键值对。
按照升序对map元素的值而非键进行排序。
如果有Lambda表达式参数，则排序结果由Lambda表达式决定。
:) SELECT mapSort(map('key2', 2, 'key3', 1, 'key1', 3)) AS res;
┌─res──────────────────────────┐
│ {'key1':3,'key2':2,'key3':1} │
└──────────────────────────────┘
:) SELECT mapSort((k, v) -> v, map('key2', 2, 'key3', 1, 'key1', 3)) AS res;
┌─res──────────────────────────┐
│ {'key3':1,'key2':2,'key1':3} │
└──────────────────────────────┘6. mapReverseSort([func], map)
参数1：func表示要执行操作的Lambda表达式。
参数2：map表示被执行的目标键值对。
和mapSort()类似，只不过排序方式改为降序。
:) SELECT mapReverseSort(map('key2', 2, 'key3', 1, 'key1', 3)) AS res;
┌─res──────────────────────────┐
│ {'key3':1,'key2':2,'key1':3} │
└──────────────────────────────┘
:) SELECT mapReverseSort((k, v) -> v, map('key2', 2, 'key3', 1, 'key1', 3)) AS res;
┌─res──────────────────────────┐
│ {'key1':3,'key2':2,'key3':1} │
└──────────────────────────────┘感谢支持
更多内容，请移步《超级个体》。