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

arrayBottomK

導入バージョン: v26.6.0 入力 Array 内の最小の K 個の要素を、昇順にソートした配列として返します。ラムダ関数 f を指定した場合、要素同士は各要素に f を適用した結果に基づいて比較されます。 f が複数の引数を受け取る場合は、追加の配列が arrayBottomK に渡され、それらの要素が f の引数に対応します。 NULL 値はスキップされ、結果には含まれません。結果のサイズは最大 K です。また、入力配列に含まれる非 NULL の要素数が K 未満の場合は、これより小さくなることがあります。結果の要素型は、入力要素型に対応する非 Nullable 型です。 arrayBottomK は高階関数です。関連項目:

代わりに最大の K 個の要素を返す arrayTopK。
同じ K 個の要素を位置 [1..K] に返しますが、残りの要素も順序未指定のまま保持し、null をスキップしない arrayPartialSort。

構文

arrayBottomK([f,] K, arr [, arr1, ... ,arrN])

引数

f(arr[, arr1, ... ,arrN]) — 任意。各要素のソートキーを計算するためのラムダ関数。ラムダ関数
K — 返される最小要素数。(U)Int8/16/32/64
arr — 配列。Array(T)
arr1, ... ,arrN — f が複数の引数を受け取る場合に使う、追加の N 個の配列。Array(T)

戻り値 arr のうち値が最も小さい要素 (またはラムダ関数の結果が最も小さい要素) を最大 K 個、昇順にソートして返します。 NULL 値はスキップされます。入力の型が Nullable(T) の場合でも、返される配列の要素型は T です。例 simple_int

Query

SELECT arrayBottomK(3, [1, 5, 2, 7, 3])

Response

[1,2,3]

skip_nulls

Query

SELECT arrayBottomK(3, [1, NULL, 5, 2, NULL, 7])

Response

[1,2,5]

fewer_than_k

Query

SELECT arrayBottomK(5, [1, NULL, 2])

Response

[1,2]

lambda_simple

Query

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

Response

[9,5]

lambda_multi

Query

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

Response

['b','c']

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* | BFloat16 | Decimal) または Tuple((U)Int* | Float* | Decimal)
v2 — 第2ベクトル。Array((U)Int* | Float* | BFloat16 | Decimal) または Tuple((U)Int* | Float* | Decimal)

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

戻り値の型は引数の型によって決まります。Array または Tuple に異なる要素型が混在している場合、結果の型は共通の上位型になります。 2 つの BFloat16 配列は Float32 で累積され、Float32 を返します (2 つの Float32 配列と同じ規則です) 。

(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 というエラーになります。 n が整数の配列の場合、指定した位置にある要素の配列を返します (ギャザー操作) 。これは arrayMap(i -> arr[i], n) と同等ですが、より効率的な別実装が使用されます。範囲外の位置では、スカラー索引の場合と同様にデフォルト値が返されます。索引の要素は Nullable にできます。要素型を Nullable でラップできる場合、NULL 索引は NULL を返し (結果の要素型も Nullable になります) 、 Nullable 内に含められない要素型 (Array、Map など) では、NULL 索引は代わりにデフォルト値を返します。これはスカラーの NULL 索引と同じ動作です。

ClickHouse の Array は 1 始まりです。

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

arrayElement(arr, n)

引数

arr — 検索対象の配列。Array(T). - n — 取得する要素の位置、または位置の配列。位置は Nullable にすることができます。(U)Int* または Array((U)Int*).

戻り値 n がスカラーの場合、型 T の要素を返します。n が配列の場合、索引の要素が Nullable であり、T を Nullable でラップできる場合は Array(Nullable(T)) を返し、それ以外の場合は Array(T) を返します。Any または Array(T) または Array(Nullable(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

索引の配列

Query

SELECT [10, 20, 30, 40][[2, 4, 1]]

Response

[20,40,10]

arrayElementOrNull

導入バージョン: v1.1.0 指定された配列の索引 n にある要素を取得します。n には任意の整数型を指定できます。索引が配列の範囲外の場合、結果の型を Nullable にできる限り、デフォルト値ではなく NULL が返されます。すでに Nullable ではなく、Nullable 内に配置できない要素型 (Array、Map など) の場合は、代わりに要素型のデフォルト値が返されます。 n が整数の配列である場合、指定された位置にある要素の配列を返します。これは arrayMap(i -> arrayElementOrNull(arr, i), n) と同等ですが、より効率的な個別の実装が使用されます。範囲外の位置および NULL 索引は、スカラー索引の場合と同じ規則に従い、結果の配列内で NULL 値になります。

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

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

arrayElementOrNull(arr, n)

引数

arr — 検索対象の配列。Array(T)。- n — 取得する要素の位置、または位置の配列。位置には NULL を指定できます。(U)Int* または Array((U)Int*)。

戻り値 n がスカラー値の場合、T を Nullable でラップできる場合は Nullable(T)、それ以外の場合は T を返します。n が配列の場合、T を Nullable でラップできる場合は Array(Nullable(T))、それ以外の場合は Array(T) を返します。Any または Nullable(T) または Array(T) または Array(Nullable(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

索引の配列

Query

SELECT arrayElementOrNull([10, 20, 30], [1, 5, 2])

Response

[10,NULL,20]

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 関数は、Array を含む1つの行を受け取り、それを展開して、Array の各要素ごとに1行ずつ、複数の行を生成します。これは、同じ行の中で入力値を出力値に対応付ける ClickHouse の通常の関数や、複数の行のグループを1つの要約行に「圧縮」または「集約」する集約関数 (GROUP BY とともに使用した場合は、要約行内の単一の値) とは対照的です。この関数が適用されたカラムを除き、他のカラムの値はそのままコピーされます。適用されたカラムの値は、対応する Array の要素の値に置き換えられます。別名の unnest 経由を含め、arrayJoin は結合中に評価される JOIN ON 条件では使用できません。このような条件では、行数を維持する必要があるためです。一方の側にのみ適用される条件、および arrayJoin に対する等価キーは、結合前に抽出されるため、影響を受けません。非選言的な ALL INNER JOIN 条件も影響を受けません。この場合、条件は代わりに結合後に適用されるためです。展開が一方の側のみに依存する場合は、結合前のサブクエリ内の ARRAY JOIN に移動してください。arrayJoin の引数が両側のカラムを参照する条件は、再構成する必要があります。

この関数は非決定論的です。同じ引数に対して異なる結果を返すことがあります。

構文

arrayJoin(arr)

別名: unnest 引数

arr — 展開する Array。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

-- The arrayJoin function affects all sections of the query, including the WHERE section. Notice the result 2, even though the subquery returned 1 row.

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

Response

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

複数の arrayJoin 関数を使用する

Query

-- A query can use multiple arrayJoin functions. In this case, the transformation is performed multiple times and the rows are multiplied.

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
ORDER BY
    city,
    browser

Response

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

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

Query

-- Using multiple arrayJoin with the same expression may not produce the expected result due to optimizations.
-- For these cases, consider modifying the repeated array expression with extra operations that do not affect join result.
-- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- is technically correct, but will annihilate result set
    arrayJoin(arrayConcat(dice, [])) as second_throw -- intentionally changed expression to force re-evaluation
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

-- Note the ARRAY JOIN syntax in the `SELECT` query below, which provides broader possibilities.
-- ARRAY JOIN allows you to convert multiple arrays with the same number of elements at a time.

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
ORDER BY
    2,
    3

Response

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

Tupleの使用

Query

-- You can also use 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
ORDER BY
    2,
    3

Response

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

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,] limit, arr [, arr1, ... ,arrN])

引数

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

戻り値 元の配列と同じサイズの配列を返します。この配列では、範囲 [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,] limit, arr [, arr1, ... ,arrN])

引数

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

戻り値 元の配列と同じサイズの配列を返します。この配列では、範囲 [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, ..., arrN — 任意。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, ..., arrN — 任意。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 複数のArrayを受け取り、すべてのソースArrayに共通して含まれるわけではない要素からなるArrayを返します。結果には一意の値のみが含まれます。

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

構文

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

引数

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

戻り値 すべてのソースArrayに共通して含まれない、重複のない要素からなるArrayを返します 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]                          │
└────────────────────────────┴────────────────────────────────┘

arrayTopK

導入バージョン: v26.6.0 入力配列から大きい要素を上位 K 個取り出し、降順にソートされた配列を返します。ラムダ関数 f が指定されている場合、各要素に f を適用した結果に基づいて要素が比較されます。 f が複数の引数を受け取る場合は、追加の配列が arrayTopK に渡され、それらの要素が f の引数に対応します。 NULL 値はスキップされ、結果には含まれません。結果のサイズは最大 K で、入力配列に K 個未満の非 NULL 要素しか含まれていない場合は、それより小さくなることがあります。結果の要素型は、入力要素型に対応する非 Nullable 型です。 arrayTopK は高階関数です。代わりに、最も小さい要素を下位 K 個返す arrayBottomK も参照してください。構文

arrayTopK([f,] K, arr [, arr1, ... ,arrN])

引数

f(arr[, arr1, ... ,arrN]) — 省略可能。各要素のソートキーを計算するためのラムダ関数。ラムダ関数
K — 返す最大要素数。(U)Int8/16/32/64
arr — 配列。Array(T)
arr1, ... ,arrN — f が複数の引数を受け取る場合の、追加の N 個の配列。Array(T)

戻り値 arr のうち値が大きい要素 (またはラムダ関数の結果が大きい要素) を最大 K 個まで、降順にソートして返します。 NULL はスキップされます。返される配列の要素型は、入力が Nullable(T) 型の場合でも T です。例 simple_int

Query

SELECT arrayTopK(3, [1, 5, 2, 7, 3])

Response

[7,5,3]

skip_nulls

Query

SELECT arrayTopK(3, [1, NULL, 5, 2, NULL, 7])

Response

[7,5,2]

fewer_than_k

Query

SELECT arrayTopK(5, [1, NULL, 2])

Response

[2,1]

lambda_simple

Query

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

Response

[1,3]

lambda_multi

Query

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

Response

['a','c']

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 の対応する位置にある要素から構成される、一意なタプルの数を数えるための追加の Array。 Array(T)

戻り値 引数が 1 つの場合は、一意な要素数を返します。引数が複数ある場合は、各 Array の対応する位置にある要素から構成される一意なタプルの数を返します。 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()

引数

なし。

戻り値 空のInt8Array。Array(T) 例 使用例

Query

SELECT emptyArrayInt8()

Response

[]

emptyArrayString

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

emptyArrayString()

引数

なし。

戻り値 空の String Array。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 のArrayを返します構文

emptyArrayUInt16()

引数

なし。

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

Query

SELECT emptyArrayUInt16()

Response

[]

emptyArrayUInt32

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

emptyArrayUInt32()

引数

なし。

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

Query

SELECT emptyArrayUInt32()

Response

[]

emptyArrayUInt64

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

emptyArrayUInt64()

引数

なし。

戻り値 空の UInt64 のArrayです。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 に設定された要素も通常の値として扱われます。 NaN 要素には、上記の NULL ルールは適用されません。 2 つの NaN 値のスカラー比較 (NaN = NaN) は 0 ですが、indexOf では NaN 要素が見つかったものとして報告される場合があります。その動作は実装の詳細です。特定の動作に依存しないでください。 NaN 要素を見つけるには、次のようにテストします。arrayFirstIndex(x -> isNaN(x), arr) はその位置を返し、arrayExists(x -> isNaN(x), arr) はフラグを返します。構文

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

length

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

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

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

length(x)

別名: OCTET_LENGTH, CARDINALITY 引数

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

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

Query

SELECT length('Hello, world!')

Response

Arrayの例

Query

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

Response

QBitの例

Query

SELECT length([0, 0, 0, 0, 0, 0, 0, 0]::QBit(Float32, 8))

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

notHas

導入バージョン: v26.8.0 配列に指定した要素が含まれていない、マップに指定したキーが含まれていない、または JSON オブジェクトに指定したパスが存在しないかどうかを返します。has の否定です。構文

notHas(haystack, needle)

引数

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

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

Query

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

Response

Array が見つかりません

Query

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

Response

Map の基本的な使い方

Query

SELECT notHas(map('a', 1, 'b', 2), 'c')

Response

JSONの基本的な使い方

Query

SELECT notHas('{"a" : 1, "b" : {"c" : 2}}'::JSON, 'b.c')

Response

randomHadamardTransform

導入バージョン: v26.7.0 浮動小数点ベクトルにランダム化 Hadamard 変換を適用します: y = (1/sqrt(k)) * (H * D * x)。ここで、 D は seed によって決まる決定論的な +/-1 符号の対角行列、H は Walsh-Hadamard 変換です。この変換は、ベクトルのエネルギーを各座標に均等に分散させる直交なノルム保存回転であり、各座標の分布をおおむねガウス分布にし、かつデータ非依存にします。スカラー量子化の前処理として有用であり、また — 切り詰めた場合には — Johnson-Lindenstrauss / subsampled-randomized-Hadamard (SRHT) のランダム射影としても利用できます。完全変換 (切り詰めなし) では、入力長はそのまま保持されます。次の長さでは厳密です:

2 のべき乗 (通常の高速 Walsh-Hadamard 変換) ;
m が {12, 20} に含まれる 2^k * m (+/-1 Hadamard 行列を持つ次数。たとえば 768 = 64 * 12, 1536 = 128 * 12, 3072 = 256 * 12, 2560 = 128 * 20) 。これは厳密な Kronecker 変換 H_(2^k) (x) H_m として適用されます (浮動小数点乗算なし) ;
64 以下の、それ以外の任意の奇数 m に対する 2^k * m (+/-1 Hadamard 行列を持たない次数 — そのような行列が存在するのは次数 1、2、および 4 の倍数のみです) 。これは厳密な Kronecker 変換 H_(2^k) (x) C_m として適用され、ここで C_m は実直交な Discrete Hartley Transform 行列です。これにより 3584 = 512 * 7、1152 = 128 * 9、1408 = 128 * 11 のような残りの埋め込みファミリーもカバーされます。

最大の奇数因子が 64 を超える長さに対する完全変換には厳密な形がなく、より長い 2 のべき乗長へのゼロ埋めが必要になります。そのため、黙ってより長いベクトルを返すのではなく、例外として拒否されます。サポートされている長さを使用するか、output_dims を渡して任意長の切り詰め射影を計算してください (下記参照) 。結果の要素型は入力と同じです。空の入力配列を渡すと、空の配列が返されます (output_dims はこれには適用されません)。

seed (省略可、デフォルト 0) : 符号パターンを選択します。同じ seed では常に同じ変換が得られます。
output_dims (省略可、デフォルトは変換長) : 先頭の output_dims 個の座標だけを残し、この変換を 任意の 長さを受け付けるランダム射影にします。この 1/sqrt(output_dims) のスケーリングにより、完全変換では結果のノルムが保存され、切り詰め時には期待値の意味でノルムが保存されます。これは変換長を超えてはいけません。なぜなら、 Discrete Hartley 因子 C_m の切り詰められたプレフィックスは、+/-1 Hadamard 行列のような一様なレバレッジを持たないため、Hartley ファミリーの長さ (または厳密な因子を持たない任意の長さ) で output_dims による切り詰めを行う場合は、ゼロ埋めした 2 のべき乗変換が使われます。こちらはその性質を保ちます。

構文

randomHadamardTransform(vector[, seed[, output_dims]])

引数

vector — 変換するベクトル。Array(BFloat16) または Array(Float32) または Array(Float64)
seed — 省略可能。決定論的な +/-1 符号のシード (デフォルトは 0) 。UInt*
output_dims — 省略可能。結果を先頭からこの数の座標に切り詰めます (デフォルトは完全変換の長さ全体で、サポートされているすべての次元で入力長と同じです) 。output_dims を指定すると、厳密な完全変換形式がない長さでも変換が有効になります。UInt*

戻り値 変換後のベクトル (要素型は入力と同じ) 。長さは変換長 (サポートされている次元の完全変換では入力長と同じ) で、必要に応じて output_dims まで切り詰められます。Array(BFloat16) または Array(Float32) または Array(Float64) 例 2 の累乗長に対する完全変換

Query

SELECT length(randomHadamardTransform([1, 2, 3, 4]::Array(Float32)))

Response

ノルムは保たれます

Query

SELECT round(arraySum(x -> x * x, randomHadamardTransform([1, 2, 3, 4]::Array(Float32))) - 30, 4)

Response

3 次元に切り詰めた射影 (任意の長さを受け付けます)

Query

SELECT length(randomHadamardTransform([1, 2, 3, 4, 5, 6, 7, 8]::Array(Float32), 42, 3))

Response

2^k * m 次元の厳密変換では、入力長がそのまま保たれます (パディングなし)

Query

SELECT length(randomHadamardTransform(CAST(range(1152), 'Array(Float32)')))

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

​arrayBottomK

​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

​arrayTopK

​arrayTranspose

​arrayUnion

​arrayUniq

​arrayWithConstant

​arrayZip

​arrayZipUnaligned

​countEqual

array

arrayAUCPR

arrayAll

arrayAutocorrelation

arrayAvg

arrayBottomK

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

arrayTopK

arrayTranspose

arrayUnion

arrayUniq

arrayWithConstant

arrayZip

arrayZipUnaligned

countEqual