Array関数 | ClickHouse Docs

array

導入バージョン: v1.1.0

関数の引数から Array を作成します。

引数は定数であり、型は共通のスーパータイプを共有している必要があります。少なくとも 1 つの引数を渡す必要があります。そうしないと、どの型の Array を作成すべきか判断できないためです。つまり、この関数を使って空の Array を作成することはできません。空の Array を作成するには、emptyArray* 関数を使用してください。

同じ機能を使うには、[ ] 演算子を使用します。

構文

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

引数

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

戻り値

Array を返します。ここで 'T' は、渡された引数の最小の共通型です。Array(T)

例

有効な使用例

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

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

誤った使い方

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

┌─a───────────────────────────┬─toTypeName(a)─────────────────────────┐
│ [5,'1998-06-16 00:00:00',5] │ Array(Variant(DateTime, Int32, 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: データセット全体の正例サンプル数。

戻り値

precision-recall (PR) 曲線の下面積を返します。Float64

例

使用例

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

┌─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

例

すべての要素が一致する場合

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

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

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

arrayAutocorrelation

導入バージョン: v26.4.0

Array の自己相関を計算します。 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)

例

線形

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

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

対称的

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

[1,-0.6666666666666669,0.16666666666666674]

定数

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

[nan,nan,nan]

制限あり

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

[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

例

基本的な例

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

2.5

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

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

6.5

arrayBottomK

導入バージョン: v26.6.0

入力 Array 内の最小の K 個の要素を、昇順にソートした配列として返します。ラムダ関数 f を指定した場合、要素同士は各要素に f を適用した結果に基づいて比較されます。 f が複数の引数を受け取る場合は、追加の配列が arrayBottomK に渡され、それらの要素が f の引数に対応します。

NULL 値はスキップされ、結果には含まれません。結果のサイズは最大 K です。また、入力配列に含まれる非 NULL の要素数が K 未満の場合は、これより小さくなることがあります。結果の要素型は、入力要素型に対応する非 Nullable 型です。

arrayBottomK は高階関数です。

arrayCompact

導入バージョン: v20.1.0

配列から、null 値を含む連続した重複要素を削除します。結果の配列における値の順序は、ソース配列での順序によって決まります。

構文

arrayCompact(arr)

引数

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

戻り値

重複した値を含まない配列を返します Array(T)

例

使用例

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

[1,nan,2,3]

arrayConcat

導入バージョン: v1.1.0

引数として渡された Array を結合します。

構文

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

引数

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

戻り値

指定された Array 引数を連結した 1 つの Array を返します。Array(T)

例

使用例

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

[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

例

使用例

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

arrayCumSum

導入バージョン: v1.1.0

ソースArrayの要素について、部分和 (累積和) を格納した Array を返します。ラムダ関数を指定した場合は、各位置の Array 要素にラムダ関数を適用した結果に基づいて和が計算されます。

構文

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

引数

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

戻り値

ソースArrayの要素の累積和からなる Array を返します。結果の型は、入力Arrayの数値型と一致します。Array(T)

例

基本的な使い方

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

[1,2,3,4]

ラムダ式を使用

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

[2,6,12]

arrayCumSumNonNegative

導入バージョン: v18.12.0

ソースArrayの要素の部分和 (累積和) からなる Array を返します。累積和が負になった場合は、0 に置き換えられます。ラムダ関数が指定されている場合、各位置の Array 要素にラムダ関数を適用した結果に基づいて和が計算されます。

構文

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

引数

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

戻り値

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

例

基本的な使い方

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

[1,2,0,1]

ラムダ式を使用する場合

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

[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*

例

使用例

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

[0,1,1,1]

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

SELECT arrayDifference([0, 10000000000000000000]);

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

arrayDistinct

導入バージョン: v1.1.0

配列内の重複を除いた要素のみを含む配列を返します。

構文

arrayDistinct(arr)

引数

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

戻り値

重複のない要素を含む Array を返します Array(T)

例

使用例

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

[1,2,3]

arrayDotProduct

導入バージョン: v23.5.0

2 つの配列の内積を返します。

構文

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つのベクトルの内積。

(U)Int* または Float* または Decimal

例

Array の例

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

32	UInt16

Tupleの例

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

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 索引と同じ動作です。

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

演算子 [n] でも同じ機能を使用できます。

第 1 引数には QBit も指定できます。n 番目のベクトル要素は、QBit 要素型の完全な精度で再構築され、その要素を含むストライドグループのビットプレーンのみが読み取られます。

構文

arrayElement(arr, n)

引数

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

戻り値

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

例

使用例

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

負の索引

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

[n]記法を使う

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

配列の範囲外の索引

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

索引の配列

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

[20,40,10]

arrayElementOrNull

導入バージョン: v1.1.0

指定された配列の索引 n にある要素を取得します。n には任意の整数型を指定できます。索引が配列の範囲外の場合、結果の型を Nullable にできる限り、デフォルト値ではなく NULL が返されます。すでに Nullable ではなく、Nullable 内に配置できない要素型 (Array、Map など) の場合は、代わりに要素型のデフォルト値が返されます。

n が整数の配列である場合、指定された位置にある要素の配列を返します。これは arrayMap(i -> arrayElementOrNull(arr, i), n) と同等ですが、より効率的な個別の実装が使用されます。範囲外の位置および NULL 索引は、スカラー索引の場合と同じ規則に従い、結果の配列内で NULL 値になります。

負の索引もサポートされています。この場合は、末尾から数えた位置に対応する要素が選択されます。たとえば、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))

例

使用例

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

負の索引

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

配列の索引が範囲外

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

\N

索引の配列

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

[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 を使った基本例

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

┌─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)

例

使用例

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

[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

例

基本的な使い方

-- With clear_depth=1 and max_array_depth=1, the result is identical to what arrayEnumerateDense would give.

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

[1,2,1,3]

多次元配列での使用

-- In this example, arrayEnumerateDenseRanked is used to obtain an array indicating, for each element of the
-- multidimensional array, what its position is among elements of the same value.
-- For the first row of the passed array, [10, 10, 30, 20], the corresponding first row of the result is [1, 1, 2, 3],
-- indicating that 10 is the first number encountered in position 1 and 2, 30 the second number encountered in position 3
-- and 20 is the third number encountered in position 4.
-- For the second row, [40, 50, 10, 30], the corresponding second row of the result is [4,5,1,2], indicating that 40
-- and 50 are the fourth and fifth numbers encountered in position 1 and 2 of that row, that another 10
-- (the first encountered number) is in position 3 and 30 (the second number encountered) is in the last position.

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

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

clear_depth を増やした場合の例

-- Changing clear_depth=2 results in the enumeration occurring separately for each row anew.

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

[[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)

例

基本的な使い方

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

[1,1,2,1]

複数の配列

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

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

ARRAY JOIN 集計

-- Each goal ID has a calculation of the number of conversions (each element in the Goals nested data structure is a goal that was reached, which we refer to as a conversion)
-- and the number of sessions. Without ARRAY JOIN, we would have counted the number of sessions as sum(Sign). But in this particular case,
-- the rows were multiplied by the nested Goals structure, so in order to count each session one time after this, we apply a condition to the
-- value of the arrayEnumerateUniq(Goals.ID) function.

CREATE TABLE visits (CounterID UInt32, Sign Int8, Goals Nested(ID UInt32)) ENGINE = Memory;

INSERT INTO visits VALUES
    (160656, 1, [53225, 53225, 56600]),
    (160656, 1, [53225, 2825062]),
    (160656, 1, [56600, 56600, 2825062]),
    (160657, 1, [53225]);

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

┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │       3 │      2 │
│   56600 │       3 │      2 │
│ 2825062 │       2 │      2 │
└─────────┴─────────┴────────┘

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

-- With clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniq would give for the same array.

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

[1,1,2]

例 2

-- with clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniqwould give for the same array.

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

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

例 3

-- In this example, arrayEnumerateUniqRanked is used to obtain an array indicating,
-- for each element of the multidimensional array, what its position is among elements
-- of the same value. For the first row of the passed array, [1, 2, 3], the corresponding
-- result is [1, 1, 1], indicating that this is the first time 1, 2 and 3 are encountered.
-- For the second row of the provided array, [2, 2, 1], the corresponding result is [2, 3, 3],
-- indicating that 2 is encountered for a second and third time, and 1 is encountered
-- for the second time. Likewise, for the third row of the provided array [3] the
-- corresponding result is [2] indicating that 3 is encountered for the second time.

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

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

例 4

-- Changing clear_depth=2, results in elements being enumerated separately for each row.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

[[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)

例

基本

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

[1,2,2,4]

with_nulls1

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

[1,NULL,NULL]

with_nulls2

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

[1]

文字列

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

['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

例

使用例

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

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) を返します

例

単一配列の例

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

[1,1,2,2]

2つの配列を使った例

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

[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

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

['abc World']

例 2

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

[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 のデフォルト値を返します。

例

使用例

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

該当なし

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

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

例

使用例

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

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

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

arrayFirstOrNull

導入バージョン: v1.1.0

func(x[, y1, y2, ... yN]) が true を返すソースArray内の最初の要素を返します。該当する要素がない場合は NULL を返します。

構文

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

引数

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

戻り値

func が true となるソースArrayの最初の要素を返します。該当する要素がない場合は NULL を返します。

例

使用例

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

該当なし

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

\N	Nullable(UInt8)

arrayFlatten

導入バージョン: v20.1.0

Array の Array をフラット化して、1つの Array に変換します。

関数:

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

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

構文

arrayFlatten(arr)

別名: flatten

引数

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

戻り値

多次元Arrayをフラット化した Array(T) を返します

例

使用例

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

[1,2,3]

arrayFold

導入バージョン: v23.10.0

1 つ以上の同じ長さの配列にラムダ関数を適用し、その結果をアキュムレータに格納します。

構文

arrayFold(λ

引数

λ(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 の値を返します。

例

使用例

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

フィボナッチ数列

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

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

複数のArrayを使用する例

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

arrayIntersect

導入バージョン: v1.1.0

複数の配列を受け取り、すべてのソース配列に共通して含まれる要素からなる配列を返します。結果には一意の値のみが含まれます。

構文

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

引数

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

戻り値

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

例

使用例

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

┌─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

例

使用例

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

0.3333333333333333

arrayJoin

導入バージョン: v1.1.0

arrayJoin 関数は、Array を含む1つの行を受け取り、それを展開して、Array の各要素ごとに1行ずつ、複数の行を生成します。これは、同じ行の中で入力値を出力値に対応付ける ClickHouse の通常の関数や、複数の行のグループを1つの要約行に「圧縮」または「集約」する集約関数 (GROUP BY とともに使用した場合は、要約行内の単一の値) とは対照的です。

この関数が適用されたカラムを除き、他のカラムの値はそのままコピーされます。適用されたカラムの値は、対応する Array の要素の値に置き換えられます。

unnest (バージョン26.5以降) は、関数呼び出し形式 (SELECT unnest(arr)) における arrayJoin の大文字・小文字を区別しない別名です。PostgreSQL のテーブルソース構文 (FROM unnest(...)、CROSS JOIN UNNEST(...)、および LATERAL) はサポートされていません。これらのクエリには ARRAY JOIN 句を使用してください。

別名の unnest 経由を含め、arrayJoin は結合中に評価される JOIN ON 条件では使用できません。このような条件では、行数を維持する必要があるためです。一方の側にのみ適用される条件、および arrayJoin に対する等価キーは、結合前に抽出されるため、影響を受けません。非選言的な ALL INNER JOIN 条件も影響を受けません。この場合、条件は代わりに結合後に適用されるためです。展開が一方の側のみに依存する場合は、結合前のサブクエリ内の ARRAY JOIN に移動してください。arrayJoin の引数が両側のカラムを参照する条件は、再構成する必要があります。

構文

arrayJoin(arr)

別名: unnest

引数

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

戻り値

arr を展開して得られる行の集合を返します。

例

基本的な使い方

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

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

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

-- 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'];

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

複数の arrayJoin 関数を使用する

-- 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

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

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

-- 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
);

┌─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構文を使う

-- 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

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

Tupleの使用

-- 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

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

arrayLast

導入バージョン: v1.1.0

ラムダ func(x [, y1, y2, ... yN]) が true を返すソースArray内の最後の要素を返します。該当する要素がない場合は、デフォルト値を返します。

構文

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

引数

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

戻り値

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

例

使用例

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

該当なし

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

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

例

使用例

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

該当なし

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

arrayLastOrNull

導入バージョン: v1.1.0

ラムダ func(x [, y1, y2, ... yN]) が true を返すソースArray内の最後の要素を返します。該当する要素がない場合は、NULL を返します。

構文

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

引数

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

戻り値

λ が真ではないソースArray内の最後の要素を返します。該当する要素がない場合は NULL を返します。

例

使用例

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

該当なし

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

\N	Nullable(UInt8)

arrayLevenshteinDistance

導入バージョン: v25.4.0

2つの配列のレーベンシュタイン距離を計算します。

構文

arrayLevenshteinDistance(from, to)

引数

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

戻り値

1 つ目と 2 つ目の配列の間のレーベンシュタイン距離。Float64

例

使用例

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

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

例

使用例

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

arrayMap

導入バージョン: v1.1.0

元のArrayの各要素にラムダ関数を適用して得られるArrayを返します。

構文

arrayMap(func, arr)

引数

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

戻り値

ラムダ関数の結果からなるArrayを返します。Array(T)

例

使用例

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

[3,4,5]

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

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

[(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)

戻り値

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

例

基本例

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

ラムダ関数の使用例

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

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)

戻り値

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

例

基本例

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

ラムダ関数での使用

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

arrayNormalizedGini

導入バージョン: v25.1.0

正規化ジニ係数を計算します。

構文

arrayNormalizedGini(predicted, label)

引数

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

戻り値

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

例

使用例

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

(0.18055555555555558,0.2638888888888889,0.6842105263157896)

arrayPartialReverseSort

導入バージョン: v23.2.0

この関数は arrayReverseSort と同じですが、limit 引数を追加することで部分ソートを行えます。

構文

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

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

[9,5,1,3]

simple_string

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

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

retain_sorted

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

[9,5]

lambda_simple

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

[1,3,5,9]

lambda_complex

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

[0,1,2]

arrayPartialShuffle

導入バージョン: v23.2.0

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

構文

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

引数

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

戻り値

要素の一部がシャッフルされた Array。Array(T)

例

no_limit1

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

[2, 4, 3, 1]

no_limit2

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

[2,3,4,1]

random_seed

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

[3, 4, 1, 2]

explicit_seed

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

[3,2,1,4]

マテリアライズ

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

┌─arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42)─┬─arrayPartialShuffle([1, 2, 3], 2, 42)─┐
│ [3,2,1,4]                                             │ [3,2,1]                               │
│ [3,2,1,4]                                             │ [3,1,2]                               │
│ [4,3,2,1]                                             │ [1,3,2]                               │
│ [1,4,3,2]                                             │ [2,1,3]                               │
│ [3,4,1,2]                                             │ [3,2,1]                               │
│ [1,2,3,4]                                             │ [3,2,1]                               │
│ [1,4,3,2]                                             │ [1,2,3]                               │
│ [1,4,3,2]                                             │ [3,2,1]                               │
│ [3,1,2,4]                                             │ [3,2,1]                               │
│ [1,3,2,4]                                             │ [2,1,3]                               │
└───────────────────────────────────────────────────────┴───────────────────────────────────────┘

arrayPartialSort

導入バージョン: v23.2.0

この関数は arraySort と同じですが、部分ソートを行うための limit 引数が追加されています。

構文

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

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

[1,3,5,9]

simple_string

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

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

retain_sorted

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

[1,3]

lambda_simple

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

[9,5,1,3]

lambda_complex

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

[2,1,0]

arrayPopBack

導入バージョン: v1.1.0

配列の最後の要素を削除します。

構文

arrayPopBack(arr)

引数

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

戻り値

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

例

使用例

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

[1,2]

arrayPopFront

導入バージョン: v1.1.0

配列の先頭の要素を取り除きます。

構文

arrayPopFront(arr)

引数

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

戻り値

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

例

使用例

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

[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

例

基本例

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

ラムダ関数での使用

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

arrayPushBack

導入バージョン: v1.1.0

配列の末尾に要素を 1 つ追加します。

構文

arrayPushBack(arr, x)

引数

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

戻り値

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

例

使用例

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

['a','b']

arrayPushFront

導入バージョン: v1.1.0

配列の先頭に要素を 1 つ追加します。

構文

arrayPushFront(arr, x)

Arguments

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

戻り値

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

Examples

Usage example

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

['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: データセット全体に含まれる負例サンプルの総数。

戻り値

ROC (receiver operating characteristic) 曲線の下の面積を返します。Float64

例

使用例

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

0.75

arrayRandomSample

導入バージョン: v23.10.0

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

構文

arrayRandomSample(arr, samples)

引数

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

戻り値

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

例

使用例

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

['cherry','apple']

多次元配列を使用する

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

[[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)

戻り値

集約関数の結果を返します

例

使用例

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

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

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

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

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

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

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

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

┌─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)

例

使用例

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

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

arrayRemove

導入バージョン: v25.11.0

配列から、指定した値と等しい要素をすべて削除します。 NULL は等しいものとして扱われます。

構文

arrayRemove(arr, elem)

別名: array_remove

引数

arr — Array(T) - elem — T

戻り値

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

例

例 1

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

[1,3]

例 2

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

['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

SELECT arrayResize([1], 3);

[1,0,0]

例 2

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

[1,NULL,NULL]

arrayReverse

導入バージョン: v1.1.0

指定された配列の要素の並び順を逆にします。

構文

arrayReverse(arr)

引数

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

戻り値

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

例

使用例

SELECT arrayReverse([1, 2, 3])

[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)

例

単一の配列を使った例

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

[1,2,2,NULL]

2つの配列を使った例

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

[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

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

[5,3,4]

例 2

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

[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) の要素に対して処理を行うラムダ関数です。ラムダ関数
source_arr — 処理対象のソース配列です。ラムダ関数
[, cond1_arr, ... , condN_arr] — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。Array(T)

戻り値

配列の配列を返します。Array(Array(T))

例

使用例

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

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

arrayRotateLeft

導入バージョン: v23.8.0

配列を、指定した要素数だけ左に回転します。n の値が負の場合は、回転量の絶対値だけ右に回転するものとして扱われます。

構文

arrayRotateLeft(arr, n)

引数

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

戻り値

指定した要素数だけ左に回転された配列 Array(T)

例

使用例

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

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

n が負の値の場合

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

[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)

例

使用例

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

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

n が負の値の場合

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

[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)

例

使用例

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

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

n が負の値の場合

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

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

デフォルト値を使用する

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

[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)

例

使用例

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

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

n が負の値の場合

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

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

デフォルト値を使用する

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

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

arrayShingles

導入バージョン: v24.1.0

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

構文

arrayShingles(arr, l)

引数

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

戻り値

生成されたシングルの配列 Array(T)

例

使用例

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

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

arrayShuffle

導入バージョン: v23.2.0

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

構文

arrayShuffle(arr [, seed])

引数

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

戻り値

要素をシャッフルした Array Array(T)

例

seed を指定しない例 (結果は不安定)

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

[1,4,2,3]

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

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

[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

例

使用例

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

0.2222222222222222

arraySlice

導入バージョン: v1.1.0

配列の一部を返します。NULL 要素も含まれます。

最初の引数には QBit も指定できます。この場合、結果は選択した次元上の QBit (次元の部分集合への射影) になります。QBit の次元はその型の一部であり、スライスでは少なくとも 1 つの次元を選択する必要があるため、この場合の offset と length は定数でなければなりません。QBit の stride-group 境界に揃ったスライスでは、ストライドが維持され、コピーを行わずに保存済みのビットプレーンストリームが再利用されます。

構文

arraySlice(arr, offset [, length])

引数

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

戻り値

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

例

使用例

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

[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

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

[0,1,3,3]

例 2

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

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

例 3

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

[-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))

例

使用例

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

[[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)

戻り値

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

例

基本例

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

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

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

arraySymmetricDifference

導入バージョン: v25.4.0

複数のArrayを受け取り、すべてのソースArrayに共通して含まれるわけではない要素からなるArrayを返します。結果には一意の値のみが含まれます。

構文

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

引数

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

戻り値

すべてのソースArrayに共通して含まれない、重複のない要素からなるArrayを返します Array(T)

例

使用例

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

┌─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

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

[7,5,3]

skip_nulls

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

[7,5,2]

fewer_than_k

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

[2,1]

lambda_simple

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

[1,3]

lambda_multi

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

['a','c']

arrayTranspose

導入バージョン: v26.4.0

二次元配列を転置します。

すべての内部配列は同じ長さである必要があります。

構文

arrayTranspose(arr)

引数

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

戻り値

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

例

正方行列

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

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

非正方行列

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

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

文字列型の要素

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

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

arrayUnion

導入バージョン: v24.10.0

複数の配列を受け取り、いずれかのソース配列に含まれるすべての要素から成る配列を返します。結果には一意の値のみが含まれます。

構文

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

引数

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

戻り値

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

例

使用例

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

┌─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 です。

渡すすべての配列は同じ長さである必要があります。

構文

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

引数

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

戻り値

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

例

単一引数

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

複数の引数

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

arrayWithConstant

導入バージョン: v20.1.0

定数 x で埋めた長さ length の配列を作成します。

構文

arrayWithConstant(N, x)

引数

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

戻り値

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

例

使用例

SELECT arrayWithConstant(3, 1)

[1,1,1]

arrayZip

導入バージョン: v20.1.0

複数の配列を 1 つの配列に結合します。結果の配列には、ソース配列の対応する要素が、引数に記載された順序でタプルにまとめられて格納されます。

構文

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

引数

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

戻り値

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

例

使用例

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

[('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, ...)

例

使用例

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

[('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

例

使用例

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

empty

導入バージョン: v1.1.0

入力された配列が空かどうかを判定します。

配列に要素が1つも含まれていない場合、その配列は空と見なされます。

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

構文

empty(arr)

引数

arr — 入力Array。Array(T)

戻り値

空のArrayの場合は 1、空でないArrayの場合は 0 を返します。UInt8

例

使用例

SELECT empty([]);

emptyArrayDate

導入バージョン: v1.1.0

Date 型の空の配列を返します

構文

emptyArrayDate()

引数

なし。

戻り値

空のDate配列。Array(T)

例

使用例

SELECT emptyArrayDate()

[]

emptyArrayDateTime

導入バージョン: v1.1.0

空のDateTime配列を返します

構文

emptyArrayDateTime()

引数

なし。

戻り値

空の DateTime の配列。Array(T)

例

使用例

SELECT emptyArrayDateTime()

[]

emptyArrayFloat32

導入バージョン: v1.1.0

空の Float32 型の配列を返します

構文

emptyArrayFloat32()

引数

なし。

戻り値

空の Float32 の配列。Array(T)

例

使用例

SELECT emptyArrayFloat32()

[]

emptyArrayFloat64

導入バージョン: v1.1.0

空のFloat64 Arrayを返します

構文

emptyArrayFloat64()

引数

なし。

戻り値

空の Float64 配列。Array(T)

例

使用例

SELECT emptyArrayFloat64()

[]

emptyArrayInt16

導入バージョン: v1.1.0

空の Int16 型の配列を返します

構文

emptyArrayInt16()

引数

なし。

戻り値

空の Int16 配列。Array(T)

例

使用例

SELECT emptyArrayInt16()

[]

emptyArrayInt32

導入バージョン: v1.1.0

空の Int32 Array を返します

構文

emptyArrayInt32()

引数

なし

戻り値

空の Int32 配列。Array(T)

例

使用例

SELECT emptyArrayInt32()

[]

emptyArrayInt64

導入バージョン: v1.1.0

空の Int64 Array を返します

構文

emptyArrayInt64()

引数

なし

戻り値

空の Int64 の配列。Array(T)

例

使用例

SELECT emptyArrayInt64()

[]

emptyArrayInt8

導入バージョン: v1.1.0

空の Int8 Array を返します

構文

emptyArrayInt8()

引数

なし。

戻り値

空のInt8Array。Array(T)

例

使用例

SELECT emptyArrayInt8()

[]

emptyArrayString

導入バージョン: v1.1.0

空のStringArrayを返します

構文

emptyArrayString()

引数

なし。

戻り値

空の String Array。Array(T)

例

使用例

SELECT emptyArrayString()

[]

emptyArrayToSingle

導入バージョン: v1.1.0

空のArrayを受け取り、デフォルト値に等しい1要素のArrayを返します。

構文

emptyArrayToSingle(arr)

引数

arr — 空のArray。Array(T)

戻り値

Array のデフォルト型の値を 1 つ持つArray。Array(T)

例

基本例

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;

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

emptyArrayUInt16

導入バージョン: v1.1.0

空の UInt16 のArrayを返します

構文

emptyArrayUInt16()

引数

なし。

戻り値

UInt16 の空のArray。 Array(T)

例

使用例

SELECT emptyArrayUInt16()

[]

emptyArrayUInt32

導入バージョン: v1.1.0

空の UInt32 Array を返します

構文

emptyArrayUInt32()

引数

なし。

戻り値

空の UInt32 のArray。Array(T)

例

使用例

SELECT emptyArrayUInt32()

[]

emptyArrayUInt64

導入バージョン: v1.1.0

空の UInt64 Arrayを返します

構文

emptyArrayUInt64()

引数

なし。

戻り値

空の UInt64 のArrayです。Array(T)

例

使用例

SELECT emptyArrayUInt64()

[]

emptyArrayUInt8

導入バージョン: v1.1.0

空の UInt8 配列を返します

構文

emptyArrayUInt8()

引数

なし。

戻り値

空の UInt8 の配列。Array(T)

例

使用例

SELECT emptyArrayUInt8()

[]

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 の基本的な使い方

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

Array が見つかりません

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

Map の基本的な使い方

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

JSON パス

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

hasAll

導入バージョン: v1.1.0

一方のArrayがもう一方のArrayの部分集合であるかどうかを判定します。

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

構文

hasAll(set, subset)

引数

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

戻り値

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

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

例

空のArray

SELECT hasAll([], [])

NULL 値を含む Array

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

異なる型の値を含む Array

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

String 型の値を含むArray

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

共通の型を持たない Array

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

Received exception:
Code: 386. DB::Exception: There is no supertype for types UInt8, String because some of them are String/FixedString/Enum and some of them are not. (NO_COMMON_TYPE)

ArrayのArray

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

hasAny

導入バージョン: v1.1.0

2 つのArrayに共通する要素があるかどうかを判定します。

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

構文

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 が空の場合

SELECT hasAny([1], [])

NULL 値を含む Array

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

異なる型の値を含むArray

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

共通の型を持たないArray

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

Received exception:
Code: 386. DB::Exception: There is no supertype for types Array(UInt8), String because some of them are Array and some of them are not. (NO_COMMON_TYPE)

Array の Array

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

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 を返します。
両方のArrayにおける値の順序は重要です。

2 つのArrayの要素同士に共通スーパータイプがない場合は、NO_COMMON_TYPE 例外を発生させます。

構文

hasSubstr(arr1, arr2)

引数

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

戻り値

Array arr1 がArray arr2 を含む場合は 1、それ以外の場合は 0 を返します。UInt8

例

両方のArrayが空の場合

SELECT hasSubstr([], [])

NULL 値を含む Array

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

異なる型の値を含むArray

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

文字列を含むArray

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

順序付けが有効なArray

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

順序が不正な Array

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

ArrayのArray

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

共通の型を持たないArray

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

Received exception:
Code: 386. DB::Exception: There is no supertype for types UInt8, String because some of them are String/FixedString/Enum and some of them are not. (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

例

基本例

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

NULL を含む Array

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

indexOfAssumeSorted

導入バージョン: v24.12.0

配列内に値 'x' を持つ要素がある場合、その最初の要素の位置 (1 から始まる) を返します。配列に検索対象の値が含まれていない場合、この関数は 0 を返します。

構文

indexOfAssumeSorted(arr, x)

引数

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

戻り値

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

例

基本例

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

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の例

SELECT length('Hello, world!')

Arrayの例

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

QBitの例

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

constexprの例

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)

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

Unicode の例

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

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

ascii_vs_utf8 の例

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

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

notEmpty

導入バージョン: v1.1.0

入力された Array が空でないかどうかを確認します。

Array は、少なくとも 1 つの要素を含んでいれば空ではないと見なされます。

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

構文

notEmpty(arr)

引数

arr — 入力配列。Array(T)

戻り値

空でない配列の場合は 1、空の配列の場合は 0 を返します。UInt8

例

使用例

SELECT notEmpty([1,2]);

notHas

導入バージョン: v26.8.0

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

構文

notHas(haystack, needle)

引数

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

戻り値

haystackに指定したneedleが含まれない場合は1、含まれる場合は0を返します。UInt8

例

Arrayの基本的な使い方

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

Array が見つかりません

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

Map の基本的な使い方

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

JSONの基本的な使い方

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

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 の累乗長に対する完全変換

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

ノルムは保たれます

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

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

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

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

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

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)

例

使用例

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

┌─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

単一の値を含むArrayを作成します。

構文

replicate(x, arr)

引数

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

戻り値

arr と同じ長さで、各要素が値 x のArrayを返します。Array(T)

例

使用例

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

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

reverse

導入バージョン: v1.1.0

入力 Array の要素の並び、または入力文字列内の文字の並びを逆順にします。

構文

reverse(arr | str)

引数

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

戻り値

要素または文字の並び順を逆にしたArrayまたは文字列を返します。

例

Arrayを逆順にする

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

[4,3,2,1]

文字列の反転

SELECT reverse('abcd');

dcba

距離関数

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