Array関数 - ClickHouse Documentation

array

導入バージョン: v1.1.0 関数の引数から配列を作成します。引数は定数であり、型は共通のスーパータイプを共有している必要があります。少なくとも 1 つの引数を渡す必要があります。そうしないと、どの型の配列を作成すべきか判断できないためです。つまり、この関数を使って空の配列を作成することはできません。空の配列を作成するには、emptyArray* 関数を使用してください。同じ機能を使うには、[ ] 演算子を使用します。構文

array(x1 [, x2, ..., xN])

引数

x1 — 任意の型 T の定数値。この引数のみを指定した場合、配列の型は T になります。 - [, x2, ..., xN] — x1 と共通の上位型を持つ、追加の N 個の定数値

戻り値 配列を返します。ここで ‘T’ は、渡された引数の最小の共通型です。Array(T) 例 有効な使用例

Query

SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)

Response

┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32)  │
└─────────┴───────────────┘

誤った使い方

Query

SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)

Response

Received exception from server (version 25.4.3):
Code: 386. DB::Exception: Received from localhost:9000. DB::Exception:
There is no supertype for types Int32, DateTime, Int8 ...

arrayAUCPR

導入バージョン: v20.4.0 適合率-再現率 (PR) 曲線の下面積を計算します。適合率-再現率曲線は、すべての閾値にわたって、y 軸に適合率、x 軸に再現率をプロットして作成されます。結果の値は 0 から 1 の範囲をとり、値が高いほどモデルの性能が高いことを示します。 PR AUC は、特に不均衡なデータセットで有用であり、そのようなケースでは ROC AUC と比べて性能をより明確に比較できます。詳細については、こちら、こちら、およびこちらを参照してください。構文

arrayAUCPR(scores, labels[, partial_offsets])

別名: arrayPRAUC 引数

cores — 予測モデルが出力するスコア。Array((U)Int*) または Array(Float*)
labels — サンプルのラベル。通常、正例は 1、負例は 0 です。Array((U)Int*) または Array(Enum)
partial_offsets —
任意。AUC 全体ではなく PR 曲線下面積の一部 (PR 空間における垂直帯に相当) を計算するための、3 つの非負整数からなる Array(T) です。このオプションは、PR AUC を分散計算する場合に便利です。配列には次の要素 [higher_partitions_tp, higher_partitions_fp, total_positives] を含める必要があります。
- higher_partitions_tp: より高いスコアのパーティションに含まれる正例ラベルの数。
- higher_partitions_fp: より高いスコアのパーティションに含まれる負例ラベルの数。
- total_positives: データセット全体の正例サンプル数。

arr_partial_offsets を使用する場合、arr_scores と arr_labels は、スコアのある区間に対応する、データセット全体の一部のパーティションのみを含む必要があります。データセットは連続するパーティションに分割する必要があり、各パーティションには、スコアが特定の範囲に入るデータの部分集合が含まれている必要があります。例えば:

あるパーティションには、範囲 [0, 0.5) のすべてのスコアを含めることができます。
別のパーティションには、範囲 [0.5, 1.0] のスコアを含めることができます。

戻り値 precision-recall (PR) 曲線の下面積を返します。Float64 例 使用例

Query

SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

Response

┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                              0.8333333333333333 │
└─────────────────────────────────────────────────┘

arrayAll

導入バージョン: v1.1.0 ラムダ func(x [, y1, y2, ... yN]) がすべての要素に対して true を返す場合は 1 を返し、それ以外の場合は 0 を返します。構文

arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) と条件配列 (y) の要素に対して動作するラムダ関数です。Lambda function
source_arr — 処理するソース配列です。Array(T)
cond1_arr, ... — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。Array(T)

戻り値 すべての要素に対してラムダ関数が true を返す場合は 1、それ以外の場合は 0 を返します。UInt8 例 すべての要素が一致する場合

Query

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])

Response

すべての要素が一致するとは限りません

Query

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])

Response

arrayAutocorrelation

導入バージョン: v26.4.0 配列の自己相関を計算します。 max_lag が指定されている場合は、[0, max_lag) の範囲内のラグについてのみ相関を計算します。 max_lag が指定されていない場合は、取り得るすべてのラグについて計算します。構文

arrayAutocorrelation(arr, [max_lag])

引数

arr — 数値の Array。Array(T)
max_lag — 任意。計算するラグの最大数です。0 以上の整数である必要があります。Integer

戻り値 Float64 の Array を返します。分散が 0 の場合は NaN を返します。Array(Float64) 例線形

Query

SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);

Response

[1, 0.4, -0.1, -0.4, -0.4]

対称的

Query

SELECT arrayAutocorrelation([10, 20, 10]);

Response

[1, -0.6666666666666669, 0.16666666666666674]

定数

Query

SELECT arrayAutocorrelation([5, 5, 5]);

Response

[nan, nan, nan]

制限あり

Query

SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);

Response

[1, 0.4]

arrayAvg

導入バージョン: v21.1.0 ソース配列の要素の平均値を返します。ラムダ関数 func が指定されている場合は、ラムダ関数の結果の要素の平均値を返します。構文

arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — 任意。ソース配列 (x) と条件配列 (y) の要素に対して適用されるラムダ関数。Lambda function
source_arr — 処理対象のソース配列。Array(T)
[, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)

戻り値 ソース配列の要素の平均値を返します。ラムダ関数が指定されている場合は、その結果の要素の平均値を返します。Float64 例 基本的な例

Query

SELECT arrayAvg([1, 2, 3, 4]);

Response

2.5

ラムダ関数を使用する場合

Query

SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;

Response

6.5

arrayCompact

導入バージョン: v20.1.0 配列から、null 値を含む連続した重複要素を削除します。結果の配列における値の順序は、ソース配列での順序によって決まります。構文

arrayCompact(arr)

引数

arr — 重複を削除する対象の配列。Array(T)

戻り値 重複した値を含まない配列を返します Array(T) 例 使用例

Query

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

Response

[1,nan,2,3]

arrayConcat

導入バージョン: v1.1.0 引数として渡された配列を結合します。 Syntax

arrayConcat(arr1 [, arr2, ... , arrN])

引数

arr1 [, arr2, ... , arrN] — 連結する N 個の配列。Array(T)

戻り値 指定された配列引数を連結した 1 つの配列を返します。Array(T) 例 使用例

Query

SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res

Response

[1, 2, 3, 4, 5, 6]

arrayCount

導入バージョン: v1.1.0 func(arr1[i], ..., arrN[i]) が true を返す要素の個数を返します。 func が指定されていない場合は、配列内の 0 以外の要素の個数を返します。 arrayCount は高階関数です。構文

arrayCount([func, ] arr1, ...)

引数

func — オプション。各配列の各要素に適用する関数。ラムダ関数
arr1, ..., arrN — N 個の配列。Array(T)

戻り値 func が true を返す要素の数を返します。func を指定しない場合は、配列内の 0 以外の要素数を返します。UInt32 例 使用例

Query

SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)

Response

arrayCumSum

導入バージョン: v1.1.0 ソース配列の要素について、部分和 (累積和) を格納した配列を返します。ラムダ関数を指定した場合は、各位置の配列要素にラムダ関数を適用した結果に基づいて和が計算されます。構文

arrayCumSum([func,] arr1[, arr2, ... , arrN])

引数

func — 任意。各位置の配列要素に適用するラムダ関数。ラムダ関数
arr1 — 数値のソース配列。Array(T)
[arr2, ..., arrN] — 任意。同じサイズの追加の配列です。指定した場合は、ラムダ関数の引数として渡されます。Array(T)

戻り値 ソース配列の要素の累積和からなる配列を返します。結果の型は、入力配列の数値型と一致します。Array(T) 例 基本的な使い方

Query

SELECT arrayCumSum([1, 1, 1, 1]) AS res

Response

[1, 2, 3, 4]

ラムダ式を使用

Query

SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res

Response

[2, 6, 12]

arrayCumSumNonNegative

導入バージョン: v18.12.0 ソース配列の要素の部分和 (累積和) からなる配列を返します。累積和が負になった場合は、0 に置き換えられます。ラムダ関数が指定されている場合、各位置の配列要素にラムダ関数を適用した結果に基づいて和が計算されます。構文

arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])

引数

func — 任意。各位置の配列要素に適用するラムダ関数。ラムダ関数
arr1 — 数値からなるソース配列。Array(T)
[arr2, ..., arrN] — 任意。同じサイズの追加配列です。指定した場合は、ラムダ関数に引数として渡されます。Array(T)

戻り値 ソース配列の要素の累積和からなる配列を返します。累積和が途中で負になった場合は 0 に置き換えられます。結果の型は入力配列の数値型と一致します。Array(T) 例 基本的な使い方

Query

SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res

Response

[1, 2, 0, 1]

ラムダ式を使用する場合

Query

SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res

Response

[2, 0, 6]

arrayDifference

導入バージョン: v1.1.0 隣接する配列要素どうしの差分を格納した配列を返します。結果の配列の最初の要素は 0、2 番目は arr[1] - arr[0]、3 番目は arr[2] - arr[1]、以降も同様です。結果の配列の要素の型は、減算における型推論の規則によって決まります (例: UInt8 - UInt8 = Int16) 。構文

arrayDifference(arr)

引数

arr — 隣接する要素同士の差分を計算する対象の Array。 Array(T)

戻り値 隣接する配列要素同士の差分を格納した配列を返します。 UInt* 例 使用例

Query

SELECT arrayDifference([1, 2, 3, 4]);

Response

[0,1,1,1]

結果型が Int64 の場合のオーバーフロー例

Query

SELECT arrayDifference([0, 10000000000000000000]);

Response

┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616]                   │
└────────────────────────────────────────────┘

arrayDistinct

導入バージョン: v1.1.0 配列内の重複を除いた要素のみを含む配列を返します。構文

arrayDistinct(arr)

引数

arr — 重複のない要素を抽出する対象の Array。Array(T)

戻り値 重複のない要素を含む Array を返します Array(T) 例 使用例

Query

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

Response

[1,2,3]

arrayDotProduct

導入バージョン: v23.5.0 2 つの配列の内積を返します。

2 つのベクトルのサイズは同じである必要があります。Array と Tuple には、異なる要素型を混在させることもできます。

構文

arrayDotProduct(v1, v2)

引数

v1 — 第1ベクトル。Array((U)Int* | Float* | Decimal) または Tuple((U)Int* | Float* | Decimal)
v2 — 第2ベクトル。Array((U)Int* | Float* | Decimal) または Tuple((U)Int* | Float* | Decimal)

戻り値 2つのベクトルの内積。

戻り値の型は引数の型によって決まります。Array または Tuple に異なる要素型が混在している場合、結果の型は共通の上位型になります。

(U)Int* または Float* または Decimal 例 Array の例

Query

SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);

Response

32    UInt16

Tupleの例

Query

SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);

Response

32    Float64

arrayElement

導入バージョン: v1.1.0 指定された配列のインデックス n にある要素を返します。n には任意の整数型を指定できます。インデックスが配列の範囲外の場合は、デフォルト値 (数値であれば 0、文字列であれば空文字列など) を返します。ただし、非定数の配列引数に対して定数インデックス 0 を指定した場合は例外で、この場合は Array indices are 1-based というエラーになります。

ClickHouse の配列は 1 始まりです。

負のインデックスもサポートされています。この場合、末尾から数えた対応する要素が選択されます。たとえば、arr[-1] は配列の最後の要素です。演算子 [n] でも同じ機能を使用できます。構文

arrayElement(arr, n)

引数

arr — 検索対象の配列。Array(T). - n — 取得する要素の位置。(U)Int*.

戻り値 指定された配列引数を結合した 1 つの配列を返します。Array(T) 例 使用例

Query

SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

Response

負のインデックス

Query

SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

Response

[n]記法を使う

Query

SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)

Response

配列の範囲外のインデックス

Query

SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

Response

arrayElementOrNull

導入バージョン: v1.1.0 指定された配列のインデックス n にある要素を取得します。n には任意の整数型を指定できます。インデックスが配列の範囲外の場合は、デフォルト値ではなく NULL が返されます。

ClickHouse の Array は 1 始まりの配列です。

負のインデックスもサポートされています。この場合は、末尾から数えた位置に対応する要素が選択されます。たとえば、arr[-1] は配列の最後の要素です。構文

arrayElementOrNull(arrays)

引数

arrays — 任意の数の配列引数。Array

戻り値 指定された配列引数を結合した 1 つの配列を返します。Array(T) 例 使用例

Query

SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

Response

負のインデックス

Query

SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

Response

配列の添字が範囲外

Query

SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

Response

NULL

arrayEnumerate

導入バージョン: v1.1.0 配列 [1, 2, 3, ..., length (arr)] を返しますこの関数は通常、ARRAY JOIN 句とともに使用されます。これにより、ARRAY JOIN の適用後に、各配列につき 1 回だけカウントできるようになります。この関数は高階関数でも使用できます。たとえば、条件に一致する要素の配列内インデックスを取得するために使用できます。構文

arrayEnumerate(arr)

引数

arr — 列挙対象の配列。Array

戻り値 配列 [1, 2, 3, ..., length (arr)] を返します。Array(UInt32) 例 ARRAY JOIN を使った基本例

Query

CREATE TABLE test
(
    `id` UInt8,
    `tag` Array(String),
    `version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);

SELECT
    id,
    tag,
    version,
    seq
FROM test
ARRAY JOIN
    tag,
    version,
    arrayEnumerate(tag) AS seq

Response

┌─id─┬─tag────────────┬─version─────┬─seq─┐
│  1 │ release-stable │ 2.4.0       │   1 │
│  1 │ dev            │ 2.6.0-alpha │   2 │
│  1 │ security       │ 2.4.0-sec1  │   3 │
└────┴────────────────┴─────────────┴─────┘

arrayEnumerateDense

導入バージョン: v18.12.0 ソース配列内で各要素が最初に出現する位置を示す、ソース配列と同じサイズの配列を返します。構文

arrayEnumerateDense(arr)

引数

arr — 番号付けする対象の配列です。Array(T)

戻り値 arr と同じサイズの配列を返します。各要素がソース配列内で最初に現れる位置を示します。Array(T) 例 使用例

Query

SELECT arrayEnumerateDense([10, 20, 10, 30])

Response

[1,2,1,3]

arrayEnumerateDenseRanked

導入バージョン: v20.1.0 ソース配列と同じサイズの配列を返します。この配列は、各要素がソース配列内で最初に出現する位置を示します。配列の内部をどの深さまで参照するかを指定できるため、多次元配列を列挙できます。構文

arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)

引数

clear_depth — 指定したレベルで要素を別々に列挙します。max_arr_depth 以下でなければなりません。UInt*
arr — 列挙対象の N 次元配列。Array(T)
max_array_depth — 有効な最大深さです。arr の深さ以下でなければなりません。UInt*

戻り値 各要素がソース配列内で最初に出現する位置を示す配列を返します。Array 例 基本的な使い方

Query

-- clear_depth=1 かつ max_array_depth=1 の場合、結果は arrayEnumerateDense と同一になります。

SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);

Response

[1,2,1,3]

多次元配列での使用

Query

-- この例では、arrayEnumerateDenseRanked を使用して、多次元配列の各要素について、
-- 同じ値を持つ要素の中での出現順位を示す配列を取得します。
-- 渡された配列の1行目 [10, 10, 30, 20] に対応する結果の1行目は [1, 1, 2, 3] となります。
-- これは、10 が位置1と2で最初に出現する数値（1番目）、30 が位置3で2番目に出現する数値、
-- 20 が位置4で3番目に出現する数値であることを示しています。
-- 2行目 [40, 50, 10, 30] に対応する結果の2行目は [4,5,1,2] となります。
-- これは、40 と 50 がその行の位置1と2でそれぞれ4番目・5番目に出現する数値であり、
-- 別の 10（最初に出現した数値）が位置3に、30（2番目に出現した数値）が最後の位置にあることを示しています。

SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);

Response

[[1,1,2,3],[4,5,1,2]]

clear_depth を増やした場合の例

Query

-- clear_depth=2 に変更すると、各行ごとに列挙がリセットされて個別に行われます。

SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);

Response

[[1, 1, 2, 3], [1, 2, 3, 4]]

arrayEnumerateUniq

導入バージョン: v1.1.0 ソース配列と同じサイズの配列を返します。この配列は、各要素について、同じ値を持つ要素の中での位置を示します。この関数は、ARRAY JOIN と配列要素の集約を使用する場合に便利です。この関数は、同じサイズの複数の配列を引数として受け取ることもできます。この場合、一意性は、すべての配列の同じ位置にある要素のタプルに対して判定されます。構文

arrayEnumerateUniq(arr1[, arr2, ... , arrN])

引数

arr1 — 処理する最初の配列。Array(T)
arr2, ... — 任意。同じサイズの追加の配列で、タプルの一意性を判定するために使用します。Array(UInt32)

戻り値 各要素について、同じ値またはタプルを持つ要素の中での位置を表す配列を返します。Array(T) 例 基本的な使い方

Query

SELECT arrayEnumerateUniq([10, 20, 10, 30]);

Response

[1, 1, 2, 1]

複数の配列

Query

SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);

Response

[1,2,1,1,2,1]

ARRAY JOIN 集計

Query

-- 各ゴールIDについて、コンバージョン数（Goalsネストデータ構造の各要素は達成されたゴールであり、これをコンバージョンと呼ぶ）
-- およびセッション数を計算する。ARRAY JOINを使用しない場合、セッション数はsum(Sign)でカウントできる。しかしこのケースでは、
-- ネストされたGoals構造によって行が増幅されるため、各セッションを1回だけカウントするには、
-- arrayEnumerateUniq(Goals.ID)関数の値に条件を適用する。

SELECT
    Goals.ID AS GoalID,
    sum(Sign) AS Reaches,
    sumIf(Sign, num = 1) AS Visits
FROM test.visits
ARRAY JOIN
    Goals,
    arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC
LIMIT 10

Response

┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │    3214 │   1097 │
│ 2825062 │    3188 │   1097 │
│   56600 │    2803 │    488 │
│ 1989037 │    2401 │    365 │
│ 2830064 │    2396 │    910 │
│ 1113562 │    2372 │    373 │
│ 3270895 │    2262 │    812 │
│ 1084657 │    2262 │    345 │
│   56599 │    2260 │    799 │
│ 3271094 │    2256 │    812 │
└─────────┴─────────┴────────┘

arrayEnumerateUniqRanked

導入バージョン: v20.1.0 ソース配列と同じ次元の配列 (または多次元配列) を返します。各要素について、同じ値を持つ要素の中で何番目に当たるかを示します。また、配列の内部をどの深さまで見るかを指定して、多次元配列を列挙できます。構文

arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)

引数

clear_depth — 指定したレベルで要素を個別に列挙します。max_arr_depth 以下の正の整数。UInt*
arr — 列挙対象の N 次元配列。Array(T)
max_array_depth — 有効な最大深度。arr の深度以下の正の整数。UInt*

戻り値 arr と同じサイズの N 次元配列を返します。各要素には、同じ値を持つ他の要素に対するその要素の位置が示されます。Array(T) 例 例 1

Query

-- clear_depth=1 かつ max_array_depth=1 の場合、arrayEnumerateUniqRanked の結果は
-- 同じ配列に対して arrayEnumerateUniq が返す結果と同一になります。

SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);

Response

[1, 1, 2]

例 2

Query

-- clear_depth=1 かつ max_array_depth=1 の場合、arrayEnumerateUniqRanked の結果は
-- 同じ配列に対して arrayEnumerateUniq が返す結果と同一になります。

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);", "[[1, 1, 1], [2, 3, 2], [2]]

Response

[1, 1, 2]

例 3

Query

-- この例では、arrayEnumerateUniqRanked を使用して、多次元配列の各要素が
-- 同じ値を持つ要素の中で何番目に出現するかを示す配列を取得します。
-- 渡された配列の1行目 [1, 2, 3] に対応する結果は [1, 1, 1] であり、
-- 1、2、3 がいずれも初めて出現することを示します。
-- 2行目 [2, 2, 1] に対応する結果は [2, 3, 3] であり、
-- 2 が2回目・3回目に出現し、1 が2回目に出現することを示します。
-- 同様に、3行目 [3] に対応する結果は [2] であり、
-- 3 が2回目に出現することを示します。

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);

Response

[[1, 1, 1], [2, 3, 2], [2]]

例 4

Query

-- clear_depth=2 に変更すると、各行ごとに要素が個別に列挙されます。
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

Response

[[1, 1, 1], [1, 2, 1], [1]]

arrayExcept

導入バージョン: v25.9.0 元の順序を保持したまま、except に含まれない source の要素からなる配列を返します。この関数は、2 つの配列に対して差集合演算を行います。source の各要素について、その要素が except に存在するかどうかを確認し (厳密比較を使用) 、存在しない場合は結果に含めます。この演算では、次の性質が維持されます。

source の要素の順序は保持されます
source 内の重複要素は、except に存在しない場合は保持されます
NULL は個別の値として扱われます

構文

arrayExcept(source, except)

引数

source — フィルタリング対象の要素を含むソース配列です。 Array(T)
except — 結果から除外する要素を含む配列です。 Array(T)

戻り値 except に含まれない source の要素を含む、入力配列と同じ型の配列を返します。 Array(T) 例基本

Query

SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])

Response

[1, 2, 2, 4]

with_nulls1

Query

SELECT arrayExcept([1, NULL, 2, NULL], [2])

Response

[1, NULL, NULL]

with_nulls2

Query

SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])

Response

[1]

文字列

Query

SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])

Response

['apple', 'cherry']

arrayExists

導入バージョン: v1.1.0 ソース配列内に func(x[, y1, y2, ... yN]) が true を返す要素が少なくとも 1 つある場合は 1 を返し、それ以外の場合は 0 を返します。構文

arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) と条件配列 (y) の要素に対して動作するラムダ関数です。ラムダ関数
source_arr — 処理するソース配列です。Array(T)
[, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。Array(T)

戻り値 少なくとも 1 つの要素に対してラムダ関数が true を返す場合は 1、それ以外の場合は 0 を返します。UInt8 例 使用例

Query

SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])

Response

arrayFill

導入バージョン: v20.1.0 arrayFill 関数は、ソース配列を先頭の要素から末尾の要素まで順番に処理し、各位置でソース配列および条件配列の要素を使ってラムダ関数の条件を評価します。位置 i でラムダ関数の評価結果が false の場合、この関数はその要素を、配列の現在の状態における位置 i-1 の要素に置き換えます。先頭の要素は、条件にかかわらず常に保持されます。構文

arrayFill(func(x [, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x [, y1, ..., yN]) — ソース配列 (x) と条件配列 (y) の要素に対して適用されるラムダ関数 func(x [, y1, y2, ... yN]) → F(x [, y1, y2, ... yN])。ラムダ関数
source_arr — 処理対象のソース配列。ラムダ関数
[, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)

戻り値 配列 Array(T) を返します例 単一配列の例

Query

SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res

Response

[1, 1, 2, 2]

2つの配列を使った例

Query

SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res

Response

[5, 5, 6, 6]

arrayFilter

導入バージョン: v1.1.0 ラムダ関数が true を返すソース配列内の要素のみを含む配列を返します。構文

arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]

引数

func(x[, y1, ..., yN]) — ソース配列 (x) と条件配列 (y) の各要素に対して処理を行うラムダ関数。ラムダ関数
source_arr — 処理対象のソース配列。Array(T)
[, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)

戻り値 ソース配列の部分集合 Array(T) を返します例 例 1

Query

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

Response

['abc World']

例 2

Query

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

Response

[2]

arrayFirst

導入バージョン: v1.1.0 func(x[, y1, y2, ... yN]) が true を返すソース配列内の最初の要素を返します。該当する要素がない場合は、デフォルト値を返します。構文

arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) と条件配列 (y) の要素に対して動作するラムダ関数。ラムダ関数。 - source_arr — 処理するソース配列。Array(T)。 - [, cond1_arr, ... , condN_arr] — 省略可能。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)。

戻り値 λ が true になるソース配列の最初の要素を返します。該当する要素がない場合は、T のデフォルト値を返します。例 使用例

Query

SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Response

該当なし

Query

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

0 UInt8

arrayFirstIndex

導入バージョン: v1.1.0 func(x[, y1, y2, ... yN]) が true を返すソース配列内の最初の要素の索引を返します。該当する要素がない場合は ‘0’ を返します。構文

arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) と条件配列 (y) の要素に対して評価を行うラムダ関数です。Lambda function。 - source_arr — 処理対象のソース配列です。Array(T)。 - [, cond1_arr, ... , condN_arr] — 省略可能。ラムダ関数に追加の引数を渡す N 個の条件配列です。Array(T)。

戻り値 func が true となるソース配列の最初の要素の索引を返します。該当する要素がない場合は 0 を返します UInt32 例 使用例

Query

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Response

一致するものはありません

Query

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])

Response

arrayFirstOrNull

導入バージョン: v1.1.0 func(x[, y1, y2, ... yN]) が true を返すソース配列内の最初の要素を返します。該当する要素がない場合は NULL を返します。構文

arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) および条件配列 (y) の要素に対して適用されるラムダ関数。Lambda function
source_arr — 処理するソース配列。Array(T)
[, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)

戻り値 func が true となるソース配列の最初の要素を返します。該当する要素がない場合は NULL を返します。例 使用例

Query

SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Response

該当なし

Query

SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

NULL Nullable(UInt8)

arrayFlatten

導入バージョン: v20.1.0 配列の配列をフラット化して、1つの配列に変換します。関数:

ネストされた配列の深さにかかわらず適用できます。
すでにフラットな配列は変更しません。

フラット化された配列には、すべてのソース配列の要素が含まれます。構文

arrayFlatten(arr)

別名: flatten 引数

arr — 多次元配列。Array(Array(T))

戻り値 多次元配列をフラット化した Array(T) を返します例 使用例

Query

SELECT arrayFlatten([[[1]], [[2], [3]]]);

Response

[1, 2, 3]

arrayFold

導入バージョン: v23.10.0 1 つ以上の同じ長さの配列にラムダ関数を適用し、その結果をアキュムレータに格納します。構文

arrayFold(λ(acc, x1 [, x2, x3, ... xN]), arr1 [, arr2, arr3, ... arrN], acc)

引数

λ(x, x1 [, x2, x3, ... xN]) — ラムダ関数 λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN])。ここで F は acc と x の配列要素に適用される演算で、その結果の acc が繰り返し再利用されます。ラムダ関数
arr1 [, arr2, arr3, ... arrN] — 演算の対象となる N 個の配列。Array(T)
acc — ラムダ関数の戻り値と同じ型のアキュムレータ値。

戻り値 最終的な acc の値を返します。例 使用例

Query

SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;

Response

フィボナッチ数列

Query

SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);

Response

┌─fibonacci─┐
│         0 │
│         1 │
│         1 │
│         2 │
│         3 │
│         5 │
│         8 │
│        13 │
│        21 │
│        34 │
└───────────┘

複数のArrayを使用する例

Query

SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;

Response

arrayIntersect

導入バージョン: v1.1.0 複数の配列を受け取り、すべてのソース配列に共通して含まれる要素からなる配列を返します。結果には一意の値のみが含まれます。構文

arrayIntersect(arr, arr1, ..., arrN)

引数

arrN — 新しい配列の作成元となる N 個の配列。 Array(T).

戻り値 N 個すべての配列に共通して含まれる重複のない要素からなる配列を返します Array(T) 例 使用例

Query

SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection

Response

┌─empty_intersection─┬─non_empty_intersection─┐
│ []                 │ [1]                    │
└────────────────────┴────────────────────────┘

arrayJaccardIndex

導入バージョン: v23.7.0 2つの配列のジャカード係数を返します。構文

arrayJaccardIndex(arr_x, arr_y)

引数

arr_x — 1 つ目の配列。Array(T)
arr_y — 2 つ目の配列。Array(T)

戻り値 arr_x と arr_y のジャカード係数を返します。Float64 例 使用例

Query

SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res

Response

0.3333333333333333

arrayJoin

導入バージョン: v1.1.0 arrayJoin 関数は、配列を含む1つの行を受け取り、それを展開して、配列の各要素ごとに1行ずつ、複数の行を生成します。これは、同じ行の中で入力値を出力値に対応付ける ClickHouse の通常の関数や、複数の行のグループを1つの要約行に「圧縮」または「集約」する集約関数 (GROUP BY とともに使用した場合は、要約行内の単一の値) とは対照的です。この関数が適用されたカラムを除き、他のカラムの値はそのままコピーされます。適用されたカラムの値は、対応する配列の要素の値に置き換えられます。構文

arrayJoin(arr)

別名: unnest 引数

arr — 展開する配列。Array(T)

戻り値 arr を展開して得られる行の集合を返します。例 基本的な使い方

Query

SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src

Response

┌─dst─┬─\'Hello\'─┬─src─────┐
│   1 │ Hello     │ [1,2,3] │
│   2 │ Hello     │ [1,2,3] │
│   3 │ Hello     │ [1,2,3] │
└─────┴───────────┴─────────┘

arrayJoin はクエリのすべての句に影響します

Query

-- arrayJoin関数はWHERE句を含むクエリのすべてのセクションに影響します。サブクエリが返したのは1行ですが、結果が2になっていることに注目してください。

SELECT sum(1) AS impressions
FROM
(
    SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];

Response

┌─impressions─┐
│           2 │
└─────────────┘

複数の arrayJoin 関数を使用する

Query

- 1つのクエリで複数のarrayJoin関数を使用できます。この場合、変換が複数回実行され、行数が乗算されます。

SELECT
    sum(1) AS impressions,
    arrayJoin(cities) AS city,
    arrayJoin(browsers) AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3

Response

┌─impressions─┬─city─────┬─browser─┐
│           2 │ Istanbul │ Chrome  │
│           1 │ Istanbul │ Firefox │
│           2 │ Berlin   │ Chrome  │
│           1 │ Berlin   │ Firefox │
│           2 │ Bobruisk │ Chrome  │
│           1 │ Bobruisk │ Firefox │
└─────────────┴──────────┴─────────┘

最適化によって予期しない結果が生じる場合

Query

-- 同じ式に対して複数の arrayJoin を使用すると、最適化により期待どおりの結果が得られない場合があります。
-- このような場合は、JOIN の結果に影響しない追加の操作を加えて、繰り返し使用する配列式を変更することを検討してください。
- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- 技術的には正しいが、結果セットが消滅してしまう
    arrayJoin(arrayConcat(dice, [])) as second_throw -- 再評価を強制するために意図的に式を変更している
FROM (
    SELECT [1, 2, 3, 4, 5, 6] as dice
);

Response

┌─first_throw─┬─second_throw─┐
│           1 │            1 │
│           1 │            2 │
│           1 │            3 │
│           1 │            4 │
│           1 │            5 │
│           1 │            6 │
│           2 │            1 │
│           2 │            2 │
│           2 │            3 │
│           2 │            4 │
│           2 │            5 │
│           2 │            6 │
│           3 │            1 │
│           3 │            2 │
│           3 │            3 │
│           3 │            4 │
│           3 │            5 │
│           3 │            6 │
│           4 │            1 │
│           4 │            2 │
│           4 │            3 │
│           4 │            4 │
│           4 │            5 │
│           4 │            6 │
│           5 │            1 │
│           5 │            2 │
│           5 │            3 │
│           5 │            4 │
│           5 │            5 │
│           5 │            6 │
│           6 │            1 │
│           6 │            2 │
│           6 │            3 │
│           6 │            4 │
│           6 │            5 │
│           6 │            6 │
└─────────────┴──────────────┘

ARRAY JOIN構文を使う

Query

-- 以下の `SELECT` クエリの ARRAY JOIN 構文に注目してください。より幅広い用途に対応できます。
-- ARRAY JOIN を使用すると、要素数が同じ複数の配列を一度に変換できます。

SELECT
    sum(1) AS impressions,
    city,
    browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
    cities AS city,
    browsers AS browser
GROUP BY
    2,
    3

Response

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Istanbul │ Firefox │
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
└─────────────┴──────────┴─────────┘

Tupleの使用

Query

-- Tupleを使用することもできます

SELECT
    sum(1) AS impressions,
    (arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
    t.2 AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3

Response

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Istanbul │ Firefox │
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
└─────────────┴──────────┴─────────┘

arrayLast

導入バージョン: v1.1.0 ラムダ func(x [, y1, y2, ... yN]) が true を返すソース配列内の最後の要素を返します。該当する要素がない場合は、デフォルト値を返します。構文

arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) および条件配列 (y) の要素に対して適用されるラムダ関数です。Lambda function。 - source — 処理対象のソース配列。Array(T)。 - [, cond1, ... , condN] — 省略可。ラムダ関数に追加の引数を渡すための N 個の条件配列です。Array(T)。

戻り値 func が true となるソース配列内の最後の要素を返します。該当する要素がない場合は、T のデフォルト値を返します。例 使用例

Query

SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

Response

該当なし

Query

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

0 UInt8

arrayLastIndex

導入バージョン: v1.1.0 func(x[, y1, y2, ... yN]) が true を返すソース配列内の最後の要素の索引を返します。該当する要素がない場合は ‘0’ を返します。構文

arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) と条件配列 (y) の要素に対して評価を行うラムダ関数。Lambda function
source_arr — 処理対象のソース配列。Array(T)
[, cond1_arr, ... , condN_arr] — 省略可能。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)

戻り値 func が true となるソース配列の最後の要素の索引を返します。該当する要素がない場合は 0 を返します。 UInt32 例 使用例

Query

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);

Response

該当なし

Query

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);

Response

arrayLastOrNull

導入バージョン: v1.1.0 ラムダ func(x [, y1, y2, ... yN]) が true を返すソース配列内の最後の要素を返します。該当する要素がない場合は、NULL を返します。構文

arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x [, y1, ..., yN]) — ソース配列 (x) と条件配列 (y) の要素に対して適用されるラムダ関数です。ラムダ関数。 - source_arr — 処理対象のソース配列。Array(T)。 - [, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)。

戻り値 λ が真ではないソース配列内の最後の要素を返します。該当する要素がない場合は NULL を返します。例 使用例

Query

SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

Response

該当なし

Query

SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

NULL Nullable(UInt8)

arrayLevenshteinDistance

導入バージョン: v25.4.0 2つの配列のレーベンシュタイン距離を計算します。構文

arrayLevenshteinDistance(from, to)

引数

from — 1 つ目の配列。Array(T)。 - to — 2 つ目の配列。Array(T)。

戻り値 1 つ目と 2 つ目の配列の間のレーベンシュタイン距離。Float64 例 使用例

Query

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

Response

arrayLevenshteinDistanceWeighted

導入バージョン: v25.4.0 各要素にカスタムの重みを設定した、2つのArrayのレーベンシュタイン距離を計算します。 Arrayとその重みの要素数は一致している必要があります。構文

arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)

引数

from — 第1の配列。Array(T)。 - to — 第2の配列。Array(T)。 - from_weights — 第1の配列の重み。Array((U)Int*|Float*)
to_weights — 第2の配列の重み。Array((U)Int*|Float*)

戻り値 各要素にカスタム重みを設定した、第1および第2の配列間のレーベンシュタイン距離。Float64 例 使用例

Query

SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])

Response

arrayMap

導入バージョン: v1.1.0 元の配列の各要素にラムダ関数を適用して得られる配列を返します。構文

arrayMap(func, arr)

引数

func — ソース配列 (x) と条件配列 (y) の要素に適用されるラムダ関数です。Lambda function
arr — 処理対象の配列を N 個指定します。Array(T)

戻り値 ラムダ関数の結果からなる配列を返します。Array(T) 例 使用例

Query

SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;

Response

[3, 4, 5]

異なる配列の要素からタプルを作成する

Query

SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res

Response

[(1, 4),(2, 5),(3, 6)]

arrayMax

導入バージョン: v21.1.0 ソース配列内の最大の要素を返します。ラムダ関数 func が指定されている場合は、その評価結果の最大値を返します。構文

arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — 任意。ソース配列 (x) と条件配列 (y) の要素に対して処理を行うラムダ関数です。ラムダ関数
source_arr — 処理対象のソース配列です。Array(T)
[, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。Array(T)

戻り値 ソース配列内の最大要素を返します。ラムダ関数が指定されている場合は、ラムダ関数の結果の最大要素を返します。例 基本例

Query

SELECT arrayMax([5, 3, 2, 7]);

Response

ラムダ関数の使用例

Query

SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

Response

arrayMin

導入バージョン: v21.1.0 ソース配列内の最小要素を返します。ラムダ関数 func が指定されている場合は、ラムダ関数の結果のうち最小の要素を返します。構文

arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — オプション。ソース配列 (x) および条件配列 (y) の要素に対して処理を行うラムダ関数。ラムダ関数
source_arr — 処理対象のソース配列。Array(T)
cond1_arr, ... — オプション。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)

戻り値 ソース配列内の最小要素を返します。ラムダ関数が指定されている場合は、その結果の最小要素を返します。例 基本例

Query

SELECT arrayMin([5, 3, 2, 7]);

Response

ラムダ関数での使用

Query

SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

Response

arrayNormalizedGini

導入バージョン: v25.1.0 正規化ジニ係数を計算します。構文

arrayNormalizedGini(predicted, label)

引数

predicted — 予測値。Array(T)
label — 正解値。Array(T)

戻り値 予測値のジニ係数、正規化値のジニ係数、および正規化ジニ係数 (= 前者2つのジニ係数の比) を含むタプル。Tuple(Float64, Float64, Float64) 例 使用例

Query

SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);

Response

(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)

arrayPartialReverseSort

導入バージョン: v23.2.0 この関数は arrayReverseSort と同じですが、limit 引数を追加することで部分ソートを行えます。

ソート済みの要素のみを残すには、arrayResize を使用します。

構文

arrayPartialReverseSort([f,] arr [, arr1, ... ,arrN], limit)

引数

f(arr[, arr1, ... ,arrN]) — 配列 x の要素に適用するラムダ関数。ラムダ関数
arr — ソート対象の配列。Array(T)
arr1, ... ,arrN — f が複数の引数を受け取る場合に指定する、追加の N 個の配列。Array(T)
limit — どこまでソートするかを示す索引値。(U)Int*

戻り値 元の配列と同じサイズの配列を返します。この配列では、範囲 [1..limit] の要素が降順にソートされます。残りの要素 (limit..N] の順序は未規定です。例 simple_int

Query

SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])

Response

[9, 5, 1, 3]

simple_string

Query

SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])

Response

['lasso','gladly','expenses','embolism']

retain_sorted

Query

SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)

Response

[9, 5]

lambda_simple

Query

SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])

Response

[1, 3, 5, 9]

lambda_complex

Query

SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

Response

[0, 1, 2]

arrayPartialShuffle

導入バージョン: v23.2.0 元の配列と同じサイズの配列を返します。この配列では、[1..limit] の範囲の要素が元の配列からランダムに選ばれた部分集合となります。残りの (limit..n] には、[1..limit] に含まれない要素が未定義の順序で格納されます。 limit の値は [1..n] の範囲内である必要があります。この範囲外の値を指定した場合は、完全な arrayShuffle を実行するのと同等です。

この関数は定数をマテリアライズしません。limit の値は [1..N] の範囲内である必要があります。この範囲外の値を指定した場合は、完全な arrayShuffle を実行するのと同等です。

構文

arrayPartialShuffle(arr [, limit[, seed]])

引数

arr — シャッフルする配列。Array(T)
seed — 任意。乱数生成に使用するシード値です。指定しない場合はランダムな値が使用されます。(U)Int*
limit — 任意。要素の入れ替え回数を [1..N] の範囲に制限するための数値です。(U)Int*

戻り値 要素の一部がシャッフルされた Array。Array(T) 例 no_limit1

Query

SELECT arrayPartialShuffle([1, 2, 3, 4], 0)

Response

[2, 4, 3, 1]

no_limit2

Query

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

Response

[4, 1, 3, 2]

random_seed

Query

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

Response

[3, 4, 1, 2]

explicit_seed

Query

SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)

Response

[3, 2, 1, 4]

マテリアライズ

Query

SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)

Response

┌─arrayPartial⋯4]), 2, 42)─┬─arrayPartial⋯ 3], 2, 42)─┐
│ [3,2,1,4]                │ [3,2,1]                  │
│ [3,2,1,4]                │ [3,2,1]                  │
│ [4,3,2,1]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,4,1,2]                │ [3,2,1]                  │
│ [1,2,3,4]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,1,2,4]                │ [3,2,1]                  │
│ [1,3,2,4]                │ [3,2,1]                  │
└──────────────────────────┴──────────────────────────┘

arrayPartialSort

導入バージョン: v23.2.0 この関数は arraySort と同じですが、部分ソートを行うための limit 引数が追加されています。

ソート済みの要素だけを残すには、arrayResize を使用します。

構文

arrayPartialSort([f,] arr [, arr1, ... ,arrN], limit)

引数

f(arr[, arr1, ... ,arrN]) — 配列 x の要素に適用するラムダ関数です。ラムダ関数
arr — ソートする Array です。Array(T)
arr1, ... ,arrN — f が複数の引数を受け取る場合に使用する、追加の N 個の配列です。Array(T)
limit — ソートを行う範囲の終端を表すインデックス値です。(U)Int*

戻り値 元の配列と同じサイズの配列を返します。この配列では、範囲 [1..limit] の要素が昇順にソートされます。残りの要素 (limit..N] の順序は未定です。例 simple_int

Query

SELECT arrayPartialSort(2, [5, 9, 1, 3])

Response

[1, 3, 5, 9]

simple_string

Query

SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])

Response

['embolism', 'expenses', 'gladly', 'lasso']

retain_sorted

Query

SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)

Response

[1, 3]

lambda_simple

Query

SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])

Response

[9, 5, 1, 3]

lambda_complex

Query

SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

Response

[2, 1, 0]

arrayPopBack

導入バージョン: v1.1.0 配列の最後の要素を削除します。構文

arrayPopBack(arr)

引数

arr — 末尾の要素を削除する配列です。Array(T)

戻り値 arr と同じ配列から末尾の要素を取り除いた配列を返します。Array(T) 例 使用例

Query

SELECT arrayPopBack([1, 2, 3]) AS res;

Response

[1, 2]

arrayPopFront

導入バージョン: v1.1.0 配列の先頭の要素を取り除きます。構文

arrayPopFront(arr)

引数

arr — 先頭の要素を削除する配列です。Array(T)

戻り値 arr と同じですが、arr の先頭要素を除いた配列を返します Array(T) 例 使用例

Query

SELECT arrayPopFront([1, 2, 3]) AS res;

Response

[2, 3]

arrayProduct

導入バージョン: v21.1.0 ソース配列内の要素の積を返します。ラムダ関数 func が指定されている場合は、そのラムダ関数の結果の各要素の積を返します。構文

arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — 任意。ソース配列 (x) と条件配列 (y) の要素に対して処理を行うラムダ関数。ラムダ関数
source_arr — 処理対象のソース配列。Array(T)
[, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)

戻り値 ソース配列の要素の積、または指定されている場合はラムダ関数の結果要素の積を返します。Float64 例 基本例

Query

SELECT arrayProduct([1, 2, 3, 4]);

Response

ラムダ関数での使用

Query

SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;

Response

arrayPushBack

導入バージョン: v1.1.0 配列の末尾に要素を 1 つ追加します。構文

arrayPushBack(arr, x)

引数

arr — 末尾に値 x を追加する対象の配列です。Array(T)
x —
配列の末尾に追加する単一の値です。Array(T)。

数値の配列に追加できるのは数値のみで、文字列の配列に追加できるのは文字列のみです。
数値を追加する場合、ClickHouse は配列のデータ型に合わせて x の型を自動的に設定します。
NULL を指定できます。この関数は配列に NULL 要素を追加し、配列要素の型は Nullable に変換されます。

ClickHouse のデータ型について詳しくは、Data types を参照してください。

戻り値 arr と同じ内容で、配列の末尾に追加の値 x が加わった配列を返します。Array(T) 例 使用例

Query

SELECT arrayPushBack(['a'], 'b') AS res;

Response

['a','b']

arrayPushFront

導入バージョン: v1.1.0 配列の先頭に要素を 1 つ追加します。構文

arrayPushFront(arr, x)

Arguments

arr — 末尾に値 x を追加する対象の配列です。Array(T)。 - x —
配列の先頭に追加する単一の値です。Array(T)。

数値の配列には数値のみ、文字列の配列には文字列のみを追加できます。
数値を追加する場合、ClickHouse は配列のデータ型に合わせて x の型を自動的に設定します。
NULL も指定できます。この関数は配列に NULL 要素を追加し、配列要素の型は Nullable に変換されます。

ClickHouse のデータ型の詳細については、Data types を参照してください。

戻り値 arr と同一ですが、配列の先頭に追加の値 x が含まれる配列を返します Array(T) Examples Usage example

Query

SELECT arrayPushFront(['b'], 'a') AS res;

Response

['a','b']

arrayROCAUC

導入バージョン: v20.4.0 receiver operating characteristic (ROC) 曲線下面積を計算します。 ROC 曲線は、すべてのしきい値にわたって、y 軸に True Positive Rate (TPR) 、x 軸に False Positive Rate (FPR) をプロットして作成されます。返される値は 0 から 1 の範囲で、値が大きいほどモデルの性能が高いことを示します。 ROC AUC (単に AUC とも呼ばれます) は、機械学習における概念です。詳細については、こちら、こちら、およびこちらを参照してください。構文

arrayROCAUC(scores, labels[, scale[, partial_offsets]])

別名: arrayAUC 引数

scores — 予測モデルが出力するスコア。Array((U)Int*) または Array(Float*)
labels — サンプルのラベル。通常、正例には 1、負例には 0 を使用します。Array((U)Int*) または Enum
scale — 任意。正規化された面積を返すかどうかを指定します。false の場合は、代わりに TP (真陽性) x FP (偽陽性) 曲線の下の面積を返します。デフォルト値: true。Bool
partial_offsets —
AUC 全体ではなく ROC 曲線の部分面積 (ROC 空間の縦方向の帯に相当) を計算するための、4 つの非負整数からなる配列です。このオプションは、ROC AUC の分散計算に役立ちます。配列には次の要素を含める必要があります: [higher_partitions_tp, higher_partitions_fp, total_positives, total_negatives]。Array の非負の Integers。任意です。
- higher_partitions_tp: より高いスコアのパーティションに含まれる正例ラベルの数。
- higher_partitions_fp: より高いスコアのパーティションに含まれる負例ラベルの数。
- total_positives: データセット全体に含まれる正例サンプルの総数。
- total_negatives: データセット全体に含まれる負例サンプルの総数。

arr_partial_offsets を使用する場合、arr_scores と arr_labels は、スコアのある区間に対応するデータセット全体の 1 つのパーティションのみを含む必要があります。データセットは連続したパーティションに分割する必要があり、各パーティションには、スコアが特定の範囲に収まるデータの部分集合が含まれている必要があります。例:

あるパーティションには、範囲 [0, 0.5) のすべてのスコアを含めることができます。
別のパーティションには、範囲 [0.5, 1.0] のスコアを含めることができます。

戻り値 ROC (receiver operating characteristic) 曲線の下の面積を返します。Float64 例 使用例

Query

SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

Response

0.75

arrayRandomSample

導入バージョン: v23.10.0 入力配列から、ランダムに選択した samples 個の要素からなる部分集合を返します。samples が入力配列のサイズを超える場合、サンプル数は配列のサイズに制限されます。つまり、配列のすべての要素が返されますが、その順序は保証されません。この関数は、フラットな配列とネストされた配列の両方を扱えます。構文

arrayRandomSample(arr, samples)

引数

arr — 要素をサンプリングする対象の入力配列、または多次元配列です。Array(T)
samples — ランダムサンプルに含める要素数です。(U)Int*

戻り値 入力配列からランダムに抽出した要素のサンプルを含む配列 Array(T) 例 使用例

Query

SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;

Response

['cherry','apple']

多次元配列を使用する

Query

SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;

Response

[[3,4],[5,6]]

arrayReduce

導入バージョン: v1.1.0 配列要素に集約関数を適用し、その結果を返します。集約関数の名前は、'max'、'sum' のようにシングルクォートで囲んだ文字列として渡します。パラメトリック集約関数を使用する場合、パラメータは 'uniqUpTo(6)' のように関数名の後のかっこ内で指定します。構文

arrayReduce(agg_f, arr1[, arr2, ... , arrN])

引数

agg_f — 定数で指定する集約関数の名前。String
arr1[, arr2, ... , arrN] — agg_f の引数に対応する N 個の配列。Array(T)

戻り値 集約関数の結果を返します例 使用例

Query

SELECT arrayReduce('max', [1, 2, 3]);

Response

┌─arrayReduce('max', [1, 2, 3])─┐
│                             3 │
└───────────────────────────────┘

複数の引数を使用する集約関数の例

Query

--集計関数が複数の引数を取る場合、この関数は同じサイズの複数のArrayに適用する必要があります。

SELECT arrayReduce('maxIf', [3, 5], [1, 0]);

Response

┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│                                    3 │
└──────────────────────────────────────┘

パラメトリック集約関数の例

Query

SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

Response

┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│                                                           4 │
└─────────────────────────────────────────────────────────────┘

arrayReduceInRanges

導入バージョン: v20.4.0 指定した範囲内の配列要素に集約関数を適用し、各範囲に対応する結果を格納した配列を返します。この関数は、arrayReduce(agg_func, arraySlice(arr1, index, length), ...) を複数回実行した場合と同じ結果を返します。構文

arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])

引数

agg_f — 使用する aggregate function の名前。String
ranges — 集約する範囲。集約を開始する索引 i と、集約対象の範囲 r を含む (i, r) 形式の Tuple の配列。Array(T) または Tuple(T)
arr1[, arr2, ... ,arrN] — aggregate function に渡す N 個の配列。Array(T)

戻り値 指定した範囲に対する aggregate function の結果を含む配列を返します。Array(T) 例 使用例

Query

SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res

Response

┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘

arrayRemove

導入バージョン: v25.11.0 配列から、指定した値と等しい要素をすべて削除します。 NULL は等しいものとして扱われます。構文

arrayRemove(arr, elem)

別名: array_remove 引数

arr — Array(T) - elem — T

戻り値 ソース配列のサブセット Array(T) を返します例 例 1

Query

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

Response

[1, 3]

例 2

Query

SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)

Response

['a', 'b']

arrayResize

導入バージョン: v1.1.0 配列の長さを変更します。構文

arrayResize(arr, size[, extender])

引数

arr — リサイズ対象の Array。Array(T)
size — -Array の新しい長さ。 size が Array の元のサイズより小さい場合、Array は右側から切り詰められます。 size が Array の初期サイズより大きい場合、Array は右側に extender の値、または Array 要素のデータ型のデフォルト値で拡張されます。
extender — Array の拡張に使用する値。NULL を指定できます。

戻り値 長さが size の Array。Array(T) 例 例 1

Query

SELECT arrayResize([1], 3);

Response

[1,0,0]

例 2

Query

SELECT arrayResize([1], 3, NULL);

Response

[1,NULL,NULL]

arrayReverse

導入バージョン: v1.1.0 指定された配列の要素の並び順を逆にします。

関数 reverse(arr) も同じ機能を持ち、Array に加えて他のデータ型にも対応しています。

構文

arrayReverse(arr)

引数

arr — 反転する配列。Array(T)

戻り値 元の配列と同じサイズで、要素が逆順に並んだ配列を返します。Array(T) 例 使用例

Query

SELECT arrayReverse([1, 2, 3])

Response

[3,2,1]

arrayReverseFill

導入バージョン: v20.1.0 arrayReverseFill 関数は、ソース配列を末尾の要素から先頭の要素へ順に処理し、各位置でソース配列および条件配列の要素を使ってラムダ条件を評価します。位置 i で条件の評価結果が false の場合、この関数はその要素を、配列の現在の状態における位置 i+1 の要素で置き換えます。最後の要素は、条件にかかわらず常に保持されます。構文

arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) と条件配列 (y) の要素に対して動作するラムダ関数です。ラムダ関数
source_arr — 処理対象のソース配列です。Array(T)
[, cond1_arr, ... , condN_arr] — 任意です。ラムダ関数に追加の引数を渡す N 個の条件配列です。Array(T)

戻り値 ソース配列の各要素がラムダ関数の結果に置き換えられた配列を返します。Array(T) 例 単一の配列を使った例

Query

SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res

Response

[1, 2, 2, NULL]

2つの配列を使った例

Query

SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;

Response

[5, 6, 6, 2]

arrayReverseSort

導入バージョン: v1.1.0 配列の要素を降順にソートします。関数 f が指定されている場合、指定した配列は、その配列要素に関数を適用した結果に基づいてソートされた後、反転されます。 f が複数の引数を受け取る場合、arrayReverseSort 関数には複数の配列が渡され、これらは func の各引数に対応します。ソート対象の配列に -Inf、NULL、NaN、または Inf が含まれている場合、これらは次の順序でソートされます。

-Inf
Inf
NaN
NULL

arrayReverseSort は高階関数です。構文

arrayReverseSort([f,] arr [, arr1, ... ,arrN)

引数

f(y1[, y2 ... yN]) — 配列 x の要素に適用するラムダ関数。 - arr — ソートする配列。 Array(T) - arr1, ..., yN — 任意。f が複数の引数を受け取る場合に指定する、追加の N 個の配列。

戻り値 ラムダ関数が指定されていない場合は、配列 x を降順にソートして返します。指定されている場合は、指定されたラムダ関数のロジックに従って配列をソートし、その後で反転した配列を返します。 Array(T)。例 例 1

Query

SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;

Response

[5,3,4]

例 2

Query

SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;

Response

[4,3,5]

arrayReverseSplit

導入バージョン: v20.1.0 ソース配列を複数の配列に分割します。func(x[, y1, ..., yN]) が 0 以外の値を返した場合、その要素の右側で配列が分割されます。最後の要素の後では分割されません。構文

arrayReverseSplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) および条件配列 (y) の要素に対して処理を行うラムダ関数です。Lambda function
source_arr — 処理対象のソース配列です。Lambda function
[, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。Array(T)

戻り値 配列の配列を返します。Array(Array(T)) 例 使用例

Query

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

Response

[[1], [2, 3, 4], [5]]

arrayRotateLeft

導入バージョン: v23.8.0 配列を、指定した要素数だけ左に回転します。n の値が負の場合は、回転量の絶対値だけ右に回転するものとして扱われます。構文

arrayRotateLeft(arr, n)

引数

arr — 要素を回転させる対象の配列。Array(T)。 - n — 回転させる要素数。(U)Int8/16/32/64。

戻り値 指定した要素数だけ左に回転された配列 Array(T) 例 使用例

Query

SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;

Response

[3,4,5,6,1,2]

n が負の値の場合

Query

SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;

Response

[5,6,1,2,3,4]

arrayRotateRight

導入バージョン: v23.8.0 配列を、指定した要素数だけ右に回転します。n が負の値の場合は、その絶対値の分だけ左に回転するものとして扱われます。構文

arrayRotateRight(arr, n)

引数

arr — 要素をローテーションする配列。Array(T)。 - n — ローテーションする要素の数。(U)Int8/16/32/64。

戻り値 指定した数だけ右にローテーションされた配列 Array(T) 例 使用例

Query

SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;

Response

[5,6,1,2,3,4]

n が負の値の場合

Query

SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;

Response

[3,4,5,6,1,2]

arrayShiftLeft

導入バージョン: v23.8.0 指定した要素数だけ配列を左にシフトします。新しい要素は、指定された引数または配列の要素型のデフォルト値で埋められます。要素数が負の場合、配列は右にシフトされます。構文

arrayShiftLeft(arr, n[, default])

引数

arr — 要素をシフトする配列。Array(T)。 - n — シフトする要素数。(U)Int8/16/32/64。 - default — 任意。新たに追加される要素のデフォルト値。

戻り値 指定した数の要素だけ左にシフトされた配列 Array(T) 例 使用例

Query

SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;

Response

[3,4,5,6,0,0]

n が負の値の場合

Query

SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;

Response

[0,0,1,2,3,4]

デフォルト値を使用する

Query

SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;

Response

[3,4,5,6,42,42]

arrayShiftRight

導入バージョン: v23.8.0 配列を指定した要素数だけ右にシフトします。新しい要素は、指定した引数または配列の要素型のデフォルト値で埋められます。要素数が負の場合、配列は左にシフトされます。構文

arrayShiftRight(arr, n[, default])

引数

arr — 要素をシフトする対象の配列です。Array(T)
n — シフトする要素の数です。(U)Int8/16/32/64
default — 省略可。新しく作成される要素のデフォルト値です。

戻り値 指定した要素数だけ右にシフトされた配列です。Array(T) 例 使用例

Query

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;

Response

[0, 0, 1, 2, 3, 4]

n が負の値の場合

Query

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;

Response

[3, 4, 5, 6, 0, 0]

デフォルト値を使用する

Query

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;

Response

[42, 42, 1, 2, 3, 4]

arrayShingles

導入バージョン: v24.1.0 シングルの配列 (文字列に対するN-gramに類似) を生成します。つまり、入力配列から指定した長さの連続した部分配列を生成します。構文

arrayShingles(arr, l)

引数

arr — shingle の配列を生成する対象の Array。Array(T)
l — 各 shingle の長さ。(U)Int*

戻り値 生成された shingle の配列 Array(T) 例 使用例

Query

SELECT arrayShingles([1, 2, 3, 4], 3) as res;

Response

[[1, 2, 3], [2, 3, 4]]

arrayShuffle

導入バージョン: v23.2.0 元の配列と同じサイズで、要素がシャッフルされた順序で格納された配列を返します。要素は、考えられるすべての順列が同じ確率で現れるように並べ替えられます。

この関数では定数はマテリアライズされません。

構文

arrayShuffle(arr [, seed])

引数

arr — シャッフルする配列です。Array(T)
seed (optional) — 省略可能です。乱数生成に使用するシード値です。指定しない場合は、ランダムな値が使用されます。(U)Int*

戻り値 要素をシャッフルした Array Array(T) 例 seed を指定しない例 (結果は不安定)

Query

SELECT arrayShuffle([1, 2, 3, 4]);

Response

[1,4,2,3]

seed なしの例 (安定した結果)

Query

SELECT arrayShuffle([1, 2, 3, 4], 41);

Response

[3,2,1,4]

arraySimilarity

導入バージョン: v25.4.0 重み付きレーベンシュタイン距離に基づいて、2 つの配列の類似度を 0 から 1 の範囲で計算します。構文

arraySimilarity(from, to, from_weights, to_weights)

引数

from — 1つ目の配列 Array(T)
to — 2つ目の配列 Array(T)
from_weights — 1つ目の配列の重み。 Array((U)Int*|Float*)
to_weights — 2つ目の配列の重み。 Array((U)Int*|Float*)

戻り値 重み付きレーベンシュタイン距離に基づく、2つの配列間の 0 から 1 の類似度を返します Float64 例 使用例

Query

SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);

Response

0.2222222222222222

arraySlice

導入バージョン: v1.1.0 配列の一部を返します。NULL 要素も含まれます。構文

arraySlice(arr, offset [, length])

引数

arr — スライス対象の Array。Array(T)
offset — 配列の端からの位置。正の値は左側からのオフセット、負の値は右側からのインデントを示します。配列要素の番号は 1 から始まります。(U)Int*
length — 必要なスライスの長さ。負の値を指定すると、関数は開区間のスライス [offset, array_length - length] を返します。値を省略すると、関数はスライス [offset, the_end_of_array] を返します。(U)Int*

戻り値 指定した offset から length 個の要素を含む配列のスライスを返します。Array(T) 例 使用例

Query

SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;

Response

[2, NULL, 4]

arraySort

導入バージョン: v1.1.0 指定された配列の要素を昇順にソートします。ラムダ関数 f が指定されている場合、ソート順は配列の各要素にラムダを適用した結果によって決まります。ラムダが複数の引数を受け取る場合、arraySort 関数には複数の配列が渡され、それぞれが f の引数に対応します。ソート対象の配列に -Inf、NULL、NaN、または Inf が含まれている場合、これらは次の順序でソートされます。

-Inf
Inf
NaN
NULL

arraySort は高階関数です。構文

arraySort([f,] arr [, arr1, ... ,arrN])

引数

f(y1[, y2 ... yN]) — 配列 x の要素に適用するラムダ関数。 - arr — ソートする配列。 Array(T) - arr1, ..., yN — 任意。f が複数の引数を受け取る場合に指定する、追加の N 個の配列。

戻り値 ラムダ関数が指定されていない場合は、配列 arr を昇順にソートして返します。指定されている場合は、指定されたラムダ関数のロジックに従ってソートされた配列を返します。 Array(T). 例 例 1

Query

SELECT arraySort([1, 3, 3, 0]);

Response

[0,1,3,3]

例 2

Query

SELECT arraySort(['hello', 'world', '!']);

Response

['!','hello','world']

例 3

Query

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

Response

[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]

arraySplit

導入バージョン: v20.1.0 ソース配列を複数の配列に分割します。func(x [, y1, ..., yN]) が 0 以外の値を返した場合、その要素の左側で配列が分割されます。最初の要素の前では配列は分割されません。構文

arraySplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — ソース配列 (x) および条件配列 (y) の要素に対して適用されるラムダ関数です。ラムダ関数。 - source_arr — 分割対象のソース配列 Array(T)。 - [, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。 Array(T)。

戻り値 配列の配列を返します Array(Array(T)) 例 使用例

Query

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

Response

[[1, 2, 3], [4, 5]]

arraySum

導入バージョン: v21.1.0 ソース配列内の要素の合計を返します。ラムダ関数 func が指定されている場合は、ラムダ関数の結果の合計を返します。構文

arraySum([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

引数

func(x[, y1, ..., yN]) — 任意。ソース配列 (x) と条件配列 (y) の要素に対して処理を行うラムダ関数。ラムダ関数
source_arr — 処理対象のソース配列。Array(T)
, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。Array(T)

戻り値 ソース配列の要素の合計、または指定した場合はラムダ関数の結果要素の合計を返します。例 基本例

Query

SELECT arraySum([1, 2, 3, 4]);

Response

ラムダ関数を使った使用方法

Query

SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);

Response

arraySymmetricDifference

導入バージョン: v25.4.0 複数の配列を受け取り、すべてのソース配列に共通して存在するわけではない要素からなる配列を返します。結果には一意の値のみが含まれます。

2 つを超える集合の対称差は、数学的には奇数個の入力集合に現れるすべての入力要素からなる集合として定義されます。一方、関数 arraySymmetricDifference は、すべての入力集合に共通して存在するわけではない入力要素の集合を単純に返します。

構文

arraySymmetricDifference(arr1, arr2, ... , arrN)

引数

arrN — 新しい配列の作成元となる N 個の配列。Array(T)。

戻り値 すべてのソース配列に共通して含まれない、重複のない要素からなる配列を返します Array(T) 例 使用例

Query

SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;

Response

┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ []                         │ [3,2]                          │
└────────────────────────────┴────────────────────────────────┘

arrayTranspose

導入バージョン: v26.4.0 二次元配列を転置します。すべての内部配列は同じ長さである必要があります。構文

arrayTranspose(arr)

引数

arr — 転置する二次元配列。すべての内部配列は同じ長さである必要があります。Array(Array(T))

戻り値 結果の要素 [i][j] が入力の要素 [j][i] に等しくなる、転置後の二次元配列。Array(Array(T)) 例 正方行列

Query

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

Response

[[1, 3], [2, 4]]

非正方行列

Query

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

Response

[[1, 4], [2, 5], [3, 6]]

文字列型の要素

Query

SELECT arrayTranspose([['a', 'b'], ['c', 'd']])

Response

[['a', 'c'], ['b', 'd']]

arrayUnion

導入バージョン: v24.10.0 複数の配列を受け取り、いずれかのソース配列に含まれるすべての要素から成る配列を返します。結果には一意の値のみが含まれます。構文

arrayUnion(arr1, arr2, ..., arrN)

引数

arrN — 新しい配列の作成元となる N 個の配列。Array(T)

戻り値 ソース配列内の一意な要素からなる配列を返します Array(T) 例 使用例

Query

SELECT
arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example

Response

┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1]   │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘

arrayUniq

導入バージョン: v1.1.0 引数が 1 つの場合は、配列内の異なる要素の数を数えます。引数が複数の場合は、複数の配列の対応する位置にある要素から構成される、異なるタプルの数を数えます。たとえば、SELECT arrayUniq([1,2], [3,4], [5,6]) は次のタプルを形成します。

位置 1: (1,3,5)
位置 2: (2,4,6)

その後、一意なタプルの数を数えます。この場合は 2 です。渡すすべての配列は同じ長さである必要があります。

配列内の一意な要素の一覧を取得するには、arrayReduce('groupUniqArray', arr) を使用できます。

構文

arrayUniq(arr1[, arr2, ..., arrN])

引数

arr1 — 一意な要素数を数える対象の Array。 Array(T)
[, arr2, ..., arrN] — 任意。複数の Array の対応する位置にある要素から構成される、一意な Tuple の数を数えるための追加の Array。 Array(T)

戻り値 引数が 1 つの場合は、一意な要素数を返します。引数が複数ある場合は、各 Array の対応する位置にある要素から構成される一意な Tuple の数を返します。 UInt32 例 単一引数

Query

SELECT arrayUniq([1, 1, 2, 2])

Response

複数の引数

Query

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

Response

arrayWithConstant

導入バージョン: v20.1.0 定数 x で埋めた長さ length の配列を作成します。構文

arrayWithConstant(N, x)

引数

length — 配列の要素数。(U)Int*
x — 配列の N 個の要素の値。型は任意です。

戻り値 値 x の N 個の要素で構成される Array を返します。Array(T) 例 使用例

Query

SELECT arrayWithConstant(3, 1)

Response

[1, 1, 1]

arrayZip

導入バージョン: v20.1.0 複数の配列を 1 つの配列に結合します。結果の配列には、ソース配列の対応する要素が、引数に記載された順序でタプルにまとめられて格納されます。構文

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

引数

arr1, arr2, ... , arrN — 1 つの配列に結合するための N 個の配列。Array(T)

戻り値 ソース配列の要素をタプルにまとめた配列を返します。タプル内のデータ型は入力配列の型と同じで、配列が渡された順序と同じ順に並びます Array(T) 例 使用例

Query

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

Response

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

arrayZipUnaligned

導入バージョン: v20.1.0 複数の配列を 1 つの配列に結合します。長さの異なる配列同士でも結合できます。結果の配列には、ソース配列の対応する要素が、引数に列挙された順序でタプルとしてまとめられて格納されます。構文

arrayZipUnaligned(arr1, arr2, ..., arrN)

引数

arr1, arr2, ..., arrN — 1つの配列に結合する N 個の配列。Array(T)

戻り値 ソース配列の要素をタプルとしてまとめた配列を返します。タプル内のデータ型は入力配列の型と同じで、配列を渡した順序もそのまま保持されます。Array(T) または Tuple(T1, T2, ...) 例 使用例

Query

SELECT arrayZipUnaligned(['a'], [1, 2, 3]);

Response

[('a', 1),(NULL, 2),(NULL, 3)]

countEqual

導入バージョン: v1.1.0 配列内で x に等しい要素の数を返します。arrayCount(elem -> elem = x, arr) と同等です。 NULL 要素は独立した値として扱われます。構文

countEqual(arr, x)

引数

arr — 検索対象の Array。Array(T)
x — 配列内で個数を数える値。任意の型。

戻り値 配列内で x に等しい要素の数を返します。UInt64 例 使用例

Query

SELECT countEqual([1, 2, NULL, NULL], NULL)

Response

empty

導入バージョン: v1.1.0 入力された配列が空かどうかを判定します。配列に要素が1つも含まれていない場合、その配列は空と見なされます。

optimize_functions_to_subcolumns 設定を有効にすることで最適化できます。optimize_functions_to_subcolumns = 1 の場合、この関数は配列カラム全体を読み取って処理する代わりに、size0 サブカラムのみを読み取ります。クエリ SELECT empty(arr) FROM TABLE; は SELECT arr.size0 = 0 FROM TABLE; に変換されます。

この関数は String や UUID に対しても使用できます。構文

empty(arr)

引数

arr — 入力Array。Array(T)

戻り値 空のArrayの場合は 1、空でないArrayの場合は 0 を返します。UInt8 例 使用例

Query

SELECT empty([]);

Response

emptyArrayDate

導入バージョン: v1.1.0 Date 型の空の配列を返します構文

emptyArrayDate()

引数

なし。

戻り値 空のDate配列。Array(T) 例 使用例

Query

SELECT emptyArrayDate

Response

[]

emptyArrayDateTime

導入バージョン: v1.1.0 空のDateTime配列を返します構文

emptyArrayDateTime()

引数

なし。

戻り値 空の DateTime の配列。Array(T) 例 使用例

Query

SELECT emptyArrayDateTime

Response

[]

emptyArrayFloat32

導入バージョン: v1.1.0 空の Float32 型の配列を返します構文

emptyArrayFloat32()

引数

なし。

戻り値 空の Float32 の配列。Array(T) 例 使用例

Query

SELECT emptyArrayFloat32

Response

[]

emptyArrayFloat64

導入バージョン: v1.1.0 空のFloat64 Arrayを返します構文

emptyArrayFloat64()

引数

なし。

戻り値 空の Float64 配列。Array(T) 例 使用例

Query

SELECT emptyArrayFloat64

Response

[]

emptyArrayInt16

導入バージョン: v1.1.0 空の Int16 型の配列を返します構文

emptyArrayInt16()

引数

なし。

戻り値 空の Int16 配列。Array(T) 例 使用例

Query

SELECT emptyArrayInt16

Response

[]

emptyArrayInt32

導入バージョン: v1.1.0 空の Int32 Array を返します構文

emptyArrayInt32()

引数

なし

戻り値 空の Int32 配列。Array(T) 例 使用例

Query

SELECT emptyArrayInt32

Response

[]

emptyArrayInt64

導入バージョン: v1.1.0 空の Int64 Array を返します構文

emptyArrayInt64()

引数

なし

戻り値 空の Int64 の配列。Array(T) 例 使用例

Query

SELECT emptyArrayInt64

Response

[]

emptyArrayInt8

導入バージョン: v1.1.0 空の Int8 Array を返します構文

emptyArrayInt8()

引数

なし。

戻り値 空のInt8配列。Array(T) 例 使用例

Query

SELECT emptyArrayInt8

Response

[]

emptyArrayString

導入バージョン: v1.1.0 空のString配列を返します構文

emptyArrayString()

引数

なし。

戻り値 空の String 配列。Array(T) 例 使用例

Query

SELECT emptyArrayString

Response

[]

emptyArrayToSingle

導入バージョン: v1.1.0 空の配列を受け取り、デフォルト値に等しい1要素の配列を返します。構文

emptyArrayToSingle(arr)

引数

arr — 空の配列。Array(T)

戻り値 Array のデフォルト型の値を 1 つ持つ配列。Array(T) 例 基本例

Query

CREATE TABLE test (
  a Array(Int32),
  b Array(String),
  c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO test VALUES ([], [], []);

SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;

Response

┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0]                   │ ['']                  │ ['1970-01-01 01:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘

emptyArrayUInt16

導入バージョン: v1.1.0 空の UInt16 の配列を返します構文

emptyArrayUInt16()

引数

なし。

戻り値 UInt16 の空の配列。 Array(T) 例 使用例

Query

SELECT emptyArrayUInt16

Response

[]

emptyArrayUInt32

導入バージョン: v1.1.0 空の UInt32 Array を返します構文

emptyArrayUInt32()

引数

なし。

戻り値 空の UInt32 の配列。Array(T) 例 使用例

Query

SELECT emptyArrayUInt32

Response

[]

emptyArrayUInt64

導入バージョン: v1.1.0 空の UInt64 配列を返します構文

emptyArrayUInt64()

引数

なし。

戻り値 空の UInt64 の配列です。Array(T) 例 使用例

Query

SELECT emptyArrayUInt64

Response

[]

emptyArrayUInt8

導入バージョン: v1.1.0 空の UInt8 配列を返します構文

emptyArrayUInt8()

引数

なし。

戻り値 空の UInt8 の配列。Array(T) 例 使用例

Query

SELECT emptyArrayUInt8

Response

[]

has

導入バージョン: v1.1.0 Array に指定した要素、Map に指定したキー、または JSONオブジェクトに指定したパスが含まれているかどうかを返します。 JSON では、ドット記法 (例: ‘a.b.c’) を使ってネストされたパスを指定できます。最初の引数が定数 Array で、2 番目の引数がカラムまたは式である場合、has(constant_array, column) は column IN (constant_array) と同様に動作し、最適化のために主キーやデータスキッピング索引を利用できます。たとえば、id が PRIMARY KEY の一部であれば、has([1, 10, 100], id) は主キー索引を活用できます。この最適化は、カラムが単調関数でラップされている場合にも適用されます (例: has([...], toDate(ts))) 。構文

has(haystack, needle)

引数

haystack — ソース配列、Map、または JSON。Array または Map または JSON
needle — 検索する値 (配列内の要素、Map のキー、または JSON のパス文字列) 。

戻り値 haystack に指定した needle が含まれている場合は 1、含まれていない場合は 0 を返します。UInt8 例 Array の基本的な使い方

Query

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

Response

Array が見つかりません

Query

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

Response

Map の基本的な使い方

Query

SELECT has(map('a', 1, 'b', 2), 'b')

Response

JSON パス

Query

SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')

Response

hasAll

導入バージョン: v1.1.0 一方の配列がもう一方の配列の部分集合であるかどうかを判定します。

空の配列は、任意の配列の部分集合です。
Null は値として処理されます。
どちらの配列でも、値の順序は関係ありません。

構文

hasAll(set, subset)

引数

set — 要素の集合を持つ、任意の型の Array。Array(T)
subset — set と共通のスーパータイプを持ち、set の部分集合かどうかを判定する対象の要素を含む、任意の型の Array。Array(T)

戻り値

1 — set に subset のすべての要素が含まれる場合。
0 — それ以外の場合。

set と subset の要素が共通のスーパータイプを持たない場合は、NO_COMMON_TYPE 例外が発生します。例 空の配列

Query

SELECT hasAll([], [])

Response

NULL 値を含む Array

Query

SELECT hasAll([1, Null], [Null])

Response

異なる型の値を含む Array

Query

SELECT hasAll([1.0, 2, 3, 4], [1, 3])

Response

String 型の値を含む配列

Query

SELECT hasAll(['a', 'b'], ['a'])

Response

共通の型を持たない Array

Query

SELECT hasAll([1], ['a'])

Response

NO_COMMON_TYPE 例外が発生します

ArrayのArray

Query

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])

Response

hasAny

導入バージョン: v1.1.0 2 つの配列に共通する要素があるかどうかを判定します。

Null は値として処理されます。
どちらの配列でも、値の順序は問いません。

構文

hasAny(arr_x, arr_y)

引数

arr_x — 要素の集合を持つ任意の型の Array。Array(T)
arr_y — Array arr_x と共通スーパータイプを持つ任意の型の Array。Array(T)

戻り値

1 — arr_x と arr_y に共通する要素が少なくとも 1 つある場合。
0 — それ以外の場合。

2 つの Array の要素同士に共通スーパータイプを持たないものがある場合は、NO_COMMON_TYPE 例外が発生します。例 一方の Array が空の場合

Query

SELECT hasAny([1], [])

Response

NULL 値を含む Array

Query

SELECT hasAny([Null], [Null, 1])

Response

異なる型の値を含む配列

Query

SELECT hasAny([-128, 1., 512], [1])

Response

共通の型がないArray

Query

SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])

Response

`NO_COMMON_TYPE` 例外が発生します

ArrayのArray

Query

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

Response

hasSubstr

導入バージョン: v20.6.0 array2 のすべての要素が、array1 にまったく同じ順序で現れるかどうかを確認します。したがって、この関数は array1 = プレフィックス + array2 + 接尾辞の場合にのみ 1 を返します。つまり、この関数は hasAll 関数と同様に、array2 のすべての要素が array1 に含まれているかどうかを確認します。さらに、array1 と array2 の両方で、それらの要素が同じ順序で現れることも確認します。

array2 が空の場合、この関数は 1 を返します。
NULL は値として処理されます。言い換えると、hasSubstr([1, 2, NULL, 3, 4], [2,3]) は 0 を返します。ただし、hasSubstr([1, 2, NULL, 3, 4], [2,NULL,3]) は 1 を返します。
両方の配列における値の順序は重要です。

2 つの配列の要素同士に共通の上位型がない場合は、NO_COMMON_TYPE 例外を発生させます。構文

hasSubstr(arr1, arr2)

引数

arr1 — 要素の集合からなる任意の型の Array。Array(T)
arr2 — 要素の集合からなる任意の型の Array。Array(T)

戻り値 配列 arr1 が配列 arr2 を含む場合は 1、それ以外の場合は 0 を返します。UInt8 例 両方の配列が空の場合

Query

SELECT hasSubstr([], [])

Response

NULL 値を含む Array

Query

SELECT hasSubstr([1, Null], [Null])

Response

異なる型の値を含むArray

Query

SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])

Response

文字列を含む配列

Query

SELECT hasSubstr(['a', 'b'], ['a'])

Response

順序付けが有効なArray

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])

Response

順序が不正な Array

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])

Response

Arrayの配列

Query

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

Response

共通の型を持たない配列

Query

SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])

Response

`NO_COMMON_TYPE` 例外が発生します

indexOf

導入バージョン: v1.1.0 配列内に値 ‘x’ を持つ最初の要素がある場合、その位置 (1 から始まる) を返します。配列に検索対象の値が含まれていない場合、関数は 0 を返します。 NULL に設定された要素も通常の値として扱われます。構文

indexOf(arr, x)

引数

arr — x を検索する対象の配列。Array(T)
x — arr 内で最初に一致する要素の値。この値に対応する索引を返します。UInt64

戻り値 arr に x が存在する場合は、最初の x の索引 (1 から始まる番号) を返します。存在しない場合は 0 を返します。UInt64 例 基本的な例

Query

SELECT indexOf([5, 4, 1, 3], 3)

Response

NULL を含む Array

Query

SELECT indexOf([1, 3, NULL, NULL], NULL)

Response

indexOfAssumeSorted

導入バージョン: v24.12.0 配列内に値 ‘x’ を持つ要素がある場合、その最初の要素の位置 (1 から始まる) を返します。配列に検索対象の値が含まれていない場合、この関数は 0 を返します。

indexOf 関数とは異なり、この関数は配列が昇順にソートされていることを前提としています。配列がソートされていない場合、結果は未定義です。

構文

indexOfAssumeSorted(arr, x)

引数

arr — 検索対象のソート済み配列。Array(T)
x — ソート済みの arr 内で最初に一致した要素のうち、その索引を返す対象となる値。UInt64

戻り値 arr 内に x が存在する場合は、最初の x の索引 (1 から始まる) を返します。存在しない場合は、0 を返します。UInt64 例 基本例

Query

SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)

Response

kql_array_sort_asc

導入バージョン: v23.10.0 1 つ以上の配列を昇順にソートします。最初の配列がソートされ、後続の配列はそのソート順に合わせて並べ替えられます。NULL 値は末尾に配置されます。これは KQL (Kusto Query Language) 互換関数です。構文

kql_array_sort_asc(array1[, array2, ..., nulls_last])

引数

array1 — ソート対象の配列です。Array(T)
array2 — 任意。array1 のソート順に合わせて並べ替える追加の配列です。Array(T)
nulls_last — 任意。NULL を最後に配置するかどうかを示すブール値です。デフォルトは true です。UInt8

戻り値 昇順にソートされた配列のタプルを返します。Tuple(Array, ...) 例 基本的な使い方

Query

SELECT kql_array_sort_asc([3, 1, 2])

Response

([1, 2, 3])

kql_array_sort_desc

導入バージョン: v23.10.0 1 つ以上の配列を降順にソートします。最初の配列がソートされ、以降の配列はその並び順に合わせて並べ替えられます。NULL 値は末尾に配置されます。これは KQL (Kusto Query Language) との互換性のための関数です。構文

kql_array_sort_desc(array1[, array2, ..., nulls_last])

引数

array1 — ソート対象の配列です。Array(T)
array2 — array1 のソート順に合わせて並べ替える、任意の追加配列です。Array(T)
nulls_last — null を末尾に配置するかどうかを示す任意のブール値です。デフォルトは true です。UInt8

戻り値 降順にソートされた配列のタプルを返します。Tuple(Array, ...) 例 基本的な使い方

Query

SELECT kql_array_sort_desc([3, 1, 2])

Response

([3, 2, 1])

length

導入バージョン: v1.1.0 文字列または配列の長さを計算します。

String または FixedString 引数の場合: 文字列のバイト数を計算します。
Array 引数の場合: 配列の要素数を計算します。
FixedString 引数に適用した場合、この関数は定数式になります。

文字列のバイト数は、Unicode の “code points” の数とも、 Unicode の “grapheme clusters” の数 (通常「文字」と呼ばれるもの) とも、表示上の文字幅とも一致しない点に注意してください。文字列に ASCII の NULL バイトを含めることは可能で、それらもカウントされます。構文

length(x)

別名: OCTET_LENGTH 引数

x — バイト数 (String/FixedString の場合) または要素数 (Array の場合) を計算する値。String または FixedString または Array(T)

戻り値 String/FixedString x のバイト数、または配列 x の要素数を返します。UInt64 例 Stringの例

Query

SELECT length('Hello, world!')

Response

Arrayの例

Query

SELECT length(['Hello', 'world'])

Response

constexprの例

Query

WITH 'hello' || toString(number) AS str
SELECT str,
isConstant(length(str)) AS str_length_is_constant,
isConstant(length(str::FixedString(6))) AS fixed_str_length_is_constant
FROM numbers(3)

Response

┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │                      0 │                            1 │
│ hello1 │                      0 │                            1 │
│ hello2 │                      0 │                            1 │
└────────┴────────────────────────┴──────────────────────────────┘

Unicode の例

Query

SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)

Response

┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │            8 │                4 │ ёлка │           10 │                5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘

ascii_vs_utf8 の例

Query

SELECT 'ábc' AS str, length(str), lengthUTF8(str)

Response

┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │            4 │               3 │
└─────┴──────────────┴─────────────────┘

notEmpty

導入バージョン: v1.1.0 入力された Array が空でないかどうかを確認します。 Array は、少なくとも 1 つの要素を含んでいれば空ではないと見なされます。

optimize_functions_to_subcolumns 設定を有効にすると、この関数を最適化できます。optimize_functions_to_subcolumns = 1 の場合、この関数は Array 全体のカラムを読み取って処理する代わりに、size0 サブカラムだけを読み取ります。クエリ SELECT notEmpty(arr) FROM table は SELECT arr.size0 != 0 FROM TABLE に変換されます。

この関数は String や UUID に対しても使用できます。構文

notEmpty(arr)

引数

arr — 入力配列。Array(T)

戻り値 空でない配列の場合は 1、空の配列の場合は 0 を返します。UInt8 例 使用例

Query

SELECT notEmpty([1,2]);

Response

range

導入バージョン: v1.1.0 start から end - 1 までの数値を、step 刻みで配列として返します。サポートされている型は次のとおりです。

UInt8/16/32/64
Int8/16/32/64]
すべての引数 start、end、step は、上記のサポート対象の型のいずれかである必要があります。返される配列の要素型は、引数の共通の上位型になります。
関数が、設定 function_range_max_elements_in_block で指定された要素数を超える合計長の配列を返す場合、例外が発生します。
いずれかの引数の型が Nullable(nothing) の場合は NULL を返します。いずれかの引数の値が NULL (Nullable(T) 型) の場合は、例外が発生します。

構文

range([start, ] end [, step])

引数

start — 任意。配列の先頭要素です。step を使用する場合は必須です。デフォルト値: 0。 - end — 必須。配列がこの値の直前まで生成される数値です。 - step — 任意。配列の各要素間の増分を指定します。デフォルト値: 1。

戻り値 start から end - 1 までを step 刻みで並べた数値の Array。Array(T) 例 使用例

Query

SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);

Response

┌─range(5)────┬─range(1, 5)─┬─range(1, 5, 2)─┬─range(-1, 5, 2)─┐
│ [0,1,2,3,4] │ [1,2,3,4]   │ [1,3]          │ [-1,1,3]        │
└─────────────┴─────────────┴────────────────┴─────────────────┘

replicate

導入バージョン: v1.1.0 単一の値を含む配列を作成します。構文

replicate(x, arr)

引数

x — 結果の配列を値 x で埋めるための値。Any
arr — 配列。Array(T)

戻り値 arr と同じ長さで、各要素が値 x の配列を返します。Array(T) 例 使用例

Query

SELECT replicate(1, ['a', 'b', 'c']);

Response

┌─replicate(1, ['a', 'b', 'c'])───┐
│ [1, 1, 1]                       │
└─────────────────────────────────┘

reverse

導入バージョン: v1.1.0 入力 Array の要素の並び、または入力文字列内の文字の並びを逆順にします。構文

reverse(arr | str)

引数

arr | str — ソース配列または文字列。Array(T) または String

戻り値 要素または文字の並び順を逆にした配列または文字列を返します。例 配列を逆順にする

Query

SELECT reverse([1, 2, 3, 4]);

Response

[4, 3, 2, 1]

文字列の反転

Query

SELECT reverse('abcd');

Response

'dcba'

距離関数

サポートされているすべての関数については、距離関数のドキュメントを参照してください。

​array

​arrayAUCPR

​arrayAll

​arrayAutocorrelation

​arrayAvg

​arrayCompact

​arrayConcat

​arrayCount

​arrayCumSum

​arrayCumSumNonNegative

​arrayDifference

​arrayDistinct

​arrayDotProduct

​arrayElement

​arrayElementOrNull

​arrayEnumerate

​arrayEnumerateDense

​arrayEnumerateDenseRanked

​arrayEnumerateUniq

​arrayEnumerateUniqRanked

​arrayExcept

​arrayExists

​arrayFill

​arrayFilter

​arrayFirst

​arrayFirstIndex

​arrayFirstOrNull

​arrayFlatten

​arrayFold

​arrayIntersect

​arrayJaccardIndex

​arrayJoin

​arrayLast

​arrayLastIndex

​arrayLastOrNull

​arrayLevenshteinDistance

​arrayLevenshteinDistanceWeighted

​arrayMap

​arrayMax

​arrayMin

​arrayNormalizedGini

​arrayPartialReverseSort

​arrayPartialShuffle

​arrayPartialSort

​arrayPopBack

​arrayPopFront

​arrayProduct

​arrayPushBack

​arrayPushFront

​arrayROCAUC

​arrayRandomSample

​arrayReduce

​arrayReduceInRanges

​arrayRemove

​arrayResize

​arrayReverse

​arrayReverseFill

​arrayReverseSort

​arrayReverseSplit

​arrayRotateLeft

​arrayRotateRight

​arrayShiftLeft

​arrayShiftRight

​arrayShingles

​arrayShuffle

​arraySimilarity

​arraySlice

​arraySort

​arraySplit

​arraySum

​arraySymmetricDifference

​arrayTranspose

​arrayUnion

​arrayUniq

​arrayWithConstant

​arrayZip

​arrayZipUnaligned

​countEqual

​empty

​emptyArrayDate

array

arrayAUCPR

arrayAll

arrayAutocorrelation

arrayAvg

arrayCompact

arrayConcat

arrayCount

arrayCumSum

arrayCumSumNonNegative

arrayDifference

arrayDistinct

arrayDotProduct

arrayElement

arrayElementOrNull

arrayEnumerate

arrayEnumerateDense

arrayEnumerateDenseRanked

arrayEnumerateUniq

arrayEnumerateUniqRanked

arrayExcept

arrayExists

arrayFill

arrayFilter

arrayFirst

arrayFirstIndex

arrayFirstOrNull

arrayFlatten

arrayFold

arrayIntersect

arrayJaccardIndex

arrayJoin

arrayLast

arrayLastIndex

arrayLastOrNull

arrayLevenshteinDistance

arrayLevenshteinDistanceWeighted

arrayMap

arrayMax

arrayMin

arrayNormalizedGini

arrayPartialReverseSort

arrayPartialShuffle

arrayPartialSort

arrayPopBack

arrayPopFront

arrayProduct

arrayPushBack

arrayPushFront

arrayROCAUC

arrayRandomSample

arrayReduce

arrayReduceInRanges

arrayRemove

arrayResize

arrayReverse

arrayReverseFill

arrayReverseSort

arrayReverseSplit

arrayRotateLeft

arrayRotateRight

arrayShiftLeft

arrayShiftRight

arrayShingles

arrayShuffle

arraySimilarity

arraySlice

arraySort

arraySplit

arraySum

arraySymmetricDifference

arrayTranspose

arrayUnion

arrayUniq

arrayWithConstant

arrayZip

arrayZipUnaligned

countEqual

empty

emptyArrayDate