> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-3a82795f.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Array関数のドキュメント
# Array関数
{/*AUTOGENERATED_START*/}
## array
導入バージョン: v1.1.0
関数の引数から配列を作成します。
引数は定数であり、型は共通のスーパータイプを共有している必要があります。
少なくとも 1 つの引数を渡す必要があります。そうしないと、どの型の配列を作成すべきか判断できないためです。
つまり、この関数を使って空の配列を作成することはできません。空の配列を作成するには、`emptyArray*` 関数を使用してください。
同じ機能を使うには、`[ ]` 演算子を使用します。
**構文**
```sql theme={null}
array(x1 [, x2, ..., xN])
```
**引数**
* `x1` — 任意の型 T の定数値。この引数のみを指定した場合、配列の型は T になります。 - `[, x2, ..., xN]` — `x1` と共通の上位型を持つ、追加の N 個の定数値
**戻り値**
配列を返します。ここで 'T' は、渡された引数の最小の共通型です。[`Array(T)`](/ja/reference/data-types/array)
**例**
**有効な使用例**
```sql title=Query theme={null}
SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)
```
```response title=Response theme={null}
┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32) │
└─────────┴───────────────┘
```
**誤った使い方**
```sql title=Query theme={null}
SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)
```
```response title=Response theme={null}
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 と比べて性能をより明確に比較できます。
詳細については、[こちら](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve)、[こちら](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1)、および [こちら](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve) を参照してください。
**構文**
```sql theme={null}
arrayAUCPR(scores, labels[, partial_offsets])
```
**別名**: `arrayPRAUC`
**引数**
* `cores` — 予測モデルが出力するスコア。[`Array((U)Int*)`](/ja/reference/data-types/array) または [`Array(Float*)`](/ja/reference/data-types/array)
* `labels` — サンプルのラベル。通常、正例は 1、負例は 0 です。[`Array((U)Int*)`](/ja/reference/data-types/array) または [`Array(Enum)`](/ja/reference/data-types/array)
* `partial_offsets` —
* 任意。AUC 全体ではなく PR 曲線下面積の一部 (PR 空間における垂直帯に相当) を計算するための、3 つの非負整数からなる [`Array(T)`](/ja/reference/data-types/array) です。このオプションは、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`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
┌─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` を返します。
**構文**
```sql theme={null}
arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) と条件配列 (`y`) の要素に対して動作するラムダ関数です。[`Lambda function`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理するソース配列です。[`Array(T)`](/ja/reference/data-types/array)
* `cond1_arr, ...` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
すべての要素に対してラムダ関数が true を返す場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**すべての要素が一致する場合**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])
```
```response title=Response theme={null}
1
```
**すべての要素が一致するとは限りません**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])
```
```response title=Response theme={null}
0
```
## arrayAutocorrelation
導入バージョン: v26.4.0
配列の自己相関を計算します。
`max_lag` が指定されている場合は、`[0, max_lag)` の範囲内のラグについてのみ相関を計算します。
`max_lag` が指定されていない場合は、取り得るすべてのラグについて計算します。
**構文**
```sql theme={null}
arrayAutocorrelation(arr, [max_lag])
```
**引数**
* `arr` — 数値の Array。[`Array(T)`](/ja/reference/data-types/array)
* `max_lag` — 任意。計算するラグの最大数です。0 以上の整数である必要があります。[`Integer`](/ja/reference/data-types/int-uint)
**戻り値**
Float64 の Array を返します。分散が 0 の場合は NaN を返します。[`Array(Float64)`](/ja/reference/data-types/array)
**例**
**線形**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);
```
```response title=Response theme={null}
[1, 0.4, -0.1, -0.4, -0.4]
```
**対称的**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([10, 20, 10]);
```
```response title=Response theme={null}
[1, -0.6666666666666669, 0.16666666666666674]
```
**定数**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([5, 5, 5]);
```
```response title=Response theme={null}
[nan, nan, nan]
```
**制限あり**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);
```
```response title=Response theme={null}
[1, 0.4]
```
## arrayAvg
導入バージョン: v21.1.0
ソース配列の要素の平均値を返します。
ラムダ関数 `func` が指定されている場合は、ラムダ関数の結果の要素の平均値を返します。
**構文**
```sql theme={null}
arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — 任意。ソース配列 (`x`) と条件配列 (`y`) の要素に対して適用されるラムダ関数。[`Lambda function`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列の要素の平均値を返します。ラムダ関数が指定されている場合は、その結果の要素の平均値を返します。[`Float64`](/ja/reference/data-types/float)
**例**
**基本的な例**
```sql title=Query theme={null}
SELECT arrayAvg([1, 2, 3, 4]);
```
```response title=Response theme={null}
2.5
```
**ラムダ関数を使用する場合**
```sql title=Query theme={null}
SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;
```
```response title=Response theme={null}
6.5
```
## arrayCompact
導入バージョン: v20.1.0
配列から、`null` 値を含む連続した重複要素を削除します。結果の配列における値の順序は、ソース配列での順序によって決まります。
**構文**
```sql theme={null}
arrayCompact(arr)
```
**引数**
* `arr` — 重複を削除する対象の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
重複した値を含まない配列を返します [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
```
```response title=Response theme={null}
[1,nan,2,3]
```
## arrayConcat
導入バージョン: v1.1.0
引数として渡された配列を結合します。
**Syntax**
```sql theme={null}
arrayConcat(arr1 [, arr2, ... , arrN])
```
**引数**
* `arr1 [, arr2, ... , arrN]` — 連結する `N` 個の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
指定された配列引数を連結した 1 つの配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
```
```response title=Response theme={null}
[1, 2, 3, 4, 5, 6]
```
## arrayCount
導入バージョン: v1.1.0
`func(arr1[i], ..., arrN[i])` が true を返す要素の個数を返します。
`func` が指定されていない場合は、配列内の 0 以外の要素の個数を返します。
`arrayCount` は[高階関数](/ja/reference/functions/regular-functions/overview#higher-order-functions)です。
**構文**
```sql theme={null}
arrayCount([func, ] arr1, ...)
```
**引数**
* `func` — オプション。各配列の各要素に適用する関数。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1, ..., arrN` — N 個の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`func` が true を返す要素の数を返します。`func` を指定しない場合は、配列内の 0 以外の要素数を返します。[`UInt32`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)
```
```response title=Response theme={null}
5
```
## arrayCumSum
導入バージョン: v1.1.0
ソース配列の要素について、部分和 (累積和) を格納した配列を返します。ラムダ関数を指定した場合は、各位置の配列要素にラムダ関数を適用した結果に基づいて和が計算されます。
**構文**
```sql theme={null}
arrayCumSum([func,] arr1[, arr2, ... , arrN])
```
**引数**
* `func` — 任意。各位置の配列要素に適用するラムダ関数。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — 数値のソース配列。[`Array(T)`](/ja/reference/data-types/array)
* `[arr2, ..., arrN]` — 任意。同じサイズの追加の配列です。指定した場合は、ラムダ関数の引数として渡されます。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列の要素の累積和からなる配列を返します。結果の型は、入力配列の数値型と一致します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**基本的な使い方**
```sql title=Query theme={null}
SELECT arrayCumSum([1, 1, 1, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 3, 4]
```
**ラムダ式を使用**
```sql title=Query theme={null}
SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res
```
```response title=Response theme={null}
[2, 6, 12]
```
## arrayCumSumNonNegative
導入バージョン: v18.12.0
ソース配列の要素の部分和 (累積和) からなる配列を返します。累積和が負になった場合は、0 に置き換えられます。ラムダ関数が指定されている場合、各位置の配列要素にラムダ関数を適用した結果に基づいて和が計算されます。
**構文**
```sql theme={null}
arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])
```
**引数**
* `func` — 任意。各位置の配列要素に適用するラムダ関数。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — 数値からなるソース配列。[`Array(T)`](/ja/reference/data-types/array)
* `[arr2, ..., arrN]` — 任意。同じサイズの追加配列です。指定した場合は、ラムダ関数に引数として渡されます。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列の要素の累積和からなる配列を返します。累積和が途中で負になった場合は 0 に置き換えられます。結果の型は入力配列の数値型と一致します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**基本的な使い方**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 0, 1]
```
**ラムダ式を使用する場合**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res
```
```response title=Response theme={null}
[2, 0, 6]
```
## arrayDifference
導入バージョン: v1.1.0
隣接する配列要素どうしの差分を格納した配列を返します。
結果の配列の最初の要素は 0、2 番目は `arr[1] - arr[0]`、3 番目は `arr[2] - arr[1]`、以降も同様です。
結果の配列の要素の型は、減算における型推論の規則によって決まります (例: `UInt8` - `UInt8` = `Int16`) 。
**構文**
```sql theme={null}
arrayDifference(arr)
```
**引数**
* `arr` — 隣接する要素同士の差分を計算する対象の Array。 [`Array(T)`](/ja/reference/data-types/array)
**戻り値**
隣接する配列要素同士の差分を格納した配列を返します。 [`UInt*`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayDifference([1, 2, 3, 4]);
```
```response title=Response theme={null}
[0,1,1,1]
```
**結果型が Int64 の場合のオーバーフロー例**
```sql title=Query theme={null}
SELECT arrayDifference([0, 10000000000000000000]);
```
```response title=Response theme={null}
┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616] │
└────────────────────────────────────────────┘
```
## arrayDistinct
導入バージョン: v1.1.0
配列内の重複を除いた要素のみを含む配列を返します。
**構文**
```sql theme={null}
arrayDistinct(arr)
```
**引数**
* `arr` — 重複のない要素を抽出する対象の Array。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
重複のない要素を含む Array を返します [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayDistinct([1, 2, 2, 3, 1]);
```
```response title=Response theme={null}
[1,2,3]
```
## arrayDotProduct
導入バージョン: v23.5.0
2 つの配列の内積を返します。
2 つのベクトルのサイズは同じである必要があります。Array と Tuple には、異なる要素型を混在させることもできます。
**構文**
```sql theme={null}
arrayDotProduct(v1, v2)
```
**引数**
* `v1` — 第1ベクトル。[`Array((U)Int* | Float* | Decimal)`](/ja/reference/data-types/array) または [`Tuple((U)Int* | Float* | Decimal)`](/ja/reference/data-types/tuple)
* `v2` — 第2ベクトル。[`Array((U)Int* | Float* | Decimal)`](/ja/reference/data-types/array) または [`Tuple((U)Int* | Float* | Decimal)`](/ja/reference/data-types/tuple)
**戻り値**
2つのベクトルの内積。
戻り値の型は引数の型によって決まります。Array または Tuple に異なる要素型が混在している場合、結果の型は共通の上位型になります。
[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`Decimal`](/ja/reference/data-types/decimal)
**例**
**Array の例**
```sql title=Query theme={null}
SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);
```
```response title=Response theme={null}
32 UInt16
```
**Tupleの例**
```sql title=Query theme={null}
SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);
```
```response title=Response theme={null}
32 Float64
```
## arrayElement
導入バージョン: v1.1.0
指定された配列のインデックス `n` にある要素を返します。`n` には任意の整数型を指定できます。
インデックスが配列の範囲外の場合は、デフォルト値 (数値であれば 0、文字列であれば空文字列など) を返します。
ただし、非定数の配列引数に対して定数インデックス 0 を指定した場合は例外で、この場合は `Array indices are 1-based` というエラーになります。
ClickHouse の配列は 1 始まりです。
負のインデックスもサポートされています。この場合、末尾から数えた対応する要素が選択されます。たとえば、`arr[-1]` は配列の最後の要素です。
演算子 `[n]` でも同じ機能を使用できます。
**構文**
```sql theme={null}
arrayElement(arr, n)
```
**引数**
* `arr` — 検索対象の配列。[`Array(T)`](/ja/reference/data-types/array). - `n` — 取得する要素の位置。[`(U)Int*`](/ja/reference/data-types/int-uint).
**戻り値**
指定された配列引数を結合した 1 つの配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**負のインデックス**
```sql title=Query theme={null}
SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**\[n]記法を使う**
```sql title=Query theme={null}
SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**配列の範囲外のインデックス**
```sql title=Query theme={null}
SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
0
```
## arrayElementOrNull
導入バージョン: v1.1.0
指定された配列のインデックス `n` にある要素を取得します。`n` には任意の整数型を指定できます。
インデックスが配列の範囲外の場合は、デフォルト値ではなく `NULL` が返されます。
ClickHouse の Array は 1 始まりの配列です。
負のインデックスもサポートされています。この場合は、末尾から数えた位置に対応する要素が選択されます。たとえば、`arr[-1]` は配列の最後の要素です。
**構文**
```sql theme={null}
arrayElementOrNull(arrays)
```
**引数**
* `arrays` — 任意の数の配列引数。[`Array`](/ja/reference/data-types/array)
**戻り値**
指定された配列引数を結合した 1 つの配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**負のインデックス**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**配列の添字が範囲外**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
NULL
```
## arrayEnumerate
導入バージョン: v1.1.0
配列 `[1, 2, 3, ..., length (arr)]` を返します
この関数は通常、[`ARRAY JOIN`](/ja/reference/statements/select/array-join) 句とともに使用されます。これにより、`ARRAY JOIN` の適用後に、各配列につき
1 回だけカウントできるようになります。
この関数は高階関数でも使用できます。たとえば、条件に一致する要素の配列内インデックスを取得するために使用できます。
**構文**
```sql theme={null}
arrayEnumerate(arr)
```
**引数**
* `arr` — 列挙対象の配列。[`Array`](/ja/reference/data-types/array)
**戻り値**
配列 `[1, 2, 3, ..., length (arr)]` を返します。[`Array(UInt32)`](/ja/reference/data-types/array)
**例**
**ARRAY JOIN を使った基本例**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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
ソース配列内で各要素が最初に出現する位置を示す、ソース配列と同じサイズの配列を返します。
**構文**
```sql theme={null}
arrayEnumerateDense(arr)
```
**引数**
* `arr` — 番号付けする対象の配列です。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`arr` と同じサイズの配列を返します。各要素がソース配列内で最初に現れる位置を示します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayEnumerateDense([10, 20, 10, 30])
```
```response title=Response theme={null}
[1,2,1,3]
```
## arrayEnumerateDenseRanked
導入バージョン: v20.1.0
ソース配列と同じサイズの配列を返します。この配列は、各要素がソース配列内で最初に出現する位置を示します。配列の内部をどの深さまで参照するかを指定できるため、多次元配列を列挙できます。
**構文**
```sql theme={null}
arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)
```
**引数**
* `clear_depth` — 指定したレベルで要素を別々に列挙します。`max_arr_depth` 以下でなければなりません。[`UInt*`](/ja/reference/data-types/int-uint)
* `arr` — 列挙対象の N 次元配列。[`Array(T)`](/ja/reference/data-types/array)
* `max_array_depth` — 有効な最大深さです。`arr` の深さ以下でなければなりません。[`UInt*`](/ja/reference/data-types/int-uint)
**戻り値**
各要素がソース配列内で最初に出現する位置を示す配列を返します。[`Array`](/ja/reference/data-types/array)
**例**
**基本的な使い方**
```sql title=Query theme={null}
-- clear_depth=1 かつ max_array_depth=1 の場合、結果は arrayEnumerateDense と同一になります。
SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);
```
```response title=Response theme={null}
[1,2,1,3]
```
**多次元配列での使用**
```sql title=Query theme={null}
-- この例では、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 title=Response theme={null}
[[1,1,2,3],[4,5,1,2]]
```
**clear\_depth を増やした場合の例**
```sql title=Query theme={null}
-- clear_depth=2 に変更すると、各行ごとに列挙がリセットされて個別に行われます。
SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);
```
```response title=Response theme={null}
[[1, 1, 2, 3], [1, 2, 3, 4]]
```
## arrayEnumerateUniq
導入バージョン: v1.1.0
ソース配列と同じサイズの配列を返します。この配列は、各要素について、同じ値を持つ要素の中での位置を示します。
この関数は、`ARRAY JOIN` と配列要素の集約を使用する場合に便利です。
この関数は、同じサイズの複数の配列を引数として受け取ることもできます。この場合、一意性は、すべての配列の同じ位置にある要素のタプルに対して判定されます。
**構文**
```sql theme={null}
arrayEnumerateUniq(arr1[, arr2, ... , arrN])
```
**引数**
* `arr1` — 処理する最初の配列。[`Array(T)`](/ja/reference/data-types/array)
* `arr2, ...` — 任意。同じサイズの追加の配列で、タプルの一意性を判定するために使用します。[`Array(UInt32)`](/ja/reference/data-types/array)
**戻り値**
各要素について、同じ値またはタプルを持つ要素の中での位置を表す配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**基本的な使い方**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([10, 20, 10, 30]);
```
```response title=Response theme={null}
[1, 1, 2, 1]
```
**複数の配列**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);
```
```response title=Response theme={null}
[1,2,1,1,2,1]
```
**ARRAY JOIN 集計**
```sql title=Query theme={null}
-- 各ゴール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 title=Response theme={null}
┌──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
ソース配列と同じ次元の配列 (または多次元配列) を返します。
各要素について、同じ値を持つ要素の中で何番目に当たるかを示します。
また、配列の内部をどの深さまで見るかを指定して、多次元配列を列挙できます。
**構文**
```sql theme={null}
arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)
```
**引数**
* `clear_depth` — 指定したレベルで要素を個別に列挙します。`max_arr_depth` 以下の正の整数。[`UInt*`](/ja/reference/data-types/int-uint)
* `arr` — 列挙対象の N 次元配列。[`Array(T)`](/ja/reference/data-types/array)
* `max_array_depth` — 有効な最大深度。`arr` の深度以下の正の整数。[`UInt*`](/ja/reference/data-types/int-uint)
**戻り値**
`arr` と同じサイズの N 次元配列を返します。各要素には、同じ値を持つ他の要素に対するその要素の位置が示されます。[`Array(T)`](/ja/reference/data-types/array)
**例**
**例 1**
```sql title=Query theme={null}
-- clear_depth=1 かつ max_array_depth=1 の場合、arrayEnumerateUniqRanked の結果は
-- 同じ配列に対して arrayEnumerateUniq が返す結果と同一になります。
SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);
```
```response title=Response theme={null}
[1, 1, 2]
```
**例 2**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
[1, 1, 2]
```
**例 3**
```sql title=Query theme={null}
-- この例では、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 title=Response theme={null}
[[1, 1, 1], [2, 3, 2], [2]]
```
**例 4**
```sql title=Query theme={null}
-- clear_depth=2 に変更すると、各行ごとに要素が個別に列挙されます。
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);
```
```response title=Response theme={null}
[[1, 1, 1], [1, 2, 1], [1]]
```
## arrayExcept
導入バージョン: v25.9.0
元の順序を保持したまま、`except` に含まれない `source` の要素からなる配列を返します。
この関数は、2 つの配列に対して差集合演算を行います。`source` の各要素について、その要素が `except` に存在するかどうかを確認し (厳密比較を使用) 、存在しない場合は結果に含めます。
この演算では、次の性質が維持されます。
1. `source` の要素の順序は保持されます
2. `source` 内の重複要素は、`except` に存在しない場合は保持されます
3. NULL は個別の値として扱われます
**構文**
```sql theme={null}
arrayExcept(source, except)
```
**引数**
* `source` — フィルタリング対象の要素を含むソース配列です。 [`Array(T)`](/ja/reference/data-types/array)
* `except` — 結果から除外する要素を含む配列です。 [`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`except` に含まれない `source` の要素を含む、入力配列と同じ型の配列を返します。 [`Array(T)`](/ja/reference/data-types/array)
**例**
**基本**
```sql title=Query theme={null}
SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])
```
```response title=Response theme={null}
[1, 2, 2, 4]
```
**with\_nulls1**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [2])
```
```response title=Response theme={null}
[1, NULL, NULL]
```
**with\_nulls2**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])
```
```response title=Response theme={null}
[1]
```
**文字列**
```sql title=Query theme={null}
SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])
```
```response title=Response theme={null}
['apple', 'cherry']
```
## arrayExists
導入バージョン: v1.1.0
ソース配列内に `func(x[, y1, y2, ... yN])` が true を返す要素が少なくとも 1 つある場合は `1` を返し、それ以外の場合は `0` を返します。
**構文**
```sql theme={null}
arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) と条件配列 (`y`) の要素に対して動作するラムダ関数です。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理するソース配列です。[`Array(T)`](/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
少なくとも 1 つの要素に対してラムダ関数が true を返す場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])
```
```response title=Response theme={null}
0
```
## arrayFill
導入バージョン: v20.1.0
`arrayFill` 関数は、ソース配列を先頭の要素から末尾の要素まで順番に処理し、
各位置でソース配列および条件配列の要素を使ってラムダ関数の条件を評価します。位置 i でラムダ関数の評価結果が
false の場合、
この関数はその要素を、配列の現在の状態における位置 i-1 の要素に置き換えます。
先頭の要素は、条件にかかわらず常に保持されます。
**構文**
```sql theme={null}
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])`。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
配列 [`Array(T)`](/ja/reference/data-types/array) を返します
**例**
**単一配列の例**
```sql title=Query theme={null}
SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 1, 2, 2]
```
**2つの配列を使った例**
```sql title=Query theme={null}
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 title=Response theme={null}
[5, 5, 6, 6]
```
## arrayFilter
導入バージョン: v1.1.0
ラムダ関数が true を返すソース配列内の要素のみを含む配列を返します。
**構文**
```sql theme={null}
arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) と条件配列 (`y`) の各要素に対して処理を行うラムダ関数。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列の部分集合 [`Array(T)`](/ja/reference/data-types/array) を返します
**例**
**例 1**
```sql title=Query theme={null}
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
```
```response title=Response theme={null}
['abc World']
```
**例 2**
```sql title=Query theme={null}
SELECT
arrayFilter(
(i, x) -> x LIKE '%World%',
arrayEnumerate(arr),
['Hello', 'abc World'] AS arr)
AS res
```
```response title=Response theme={null}
[2]
```
## arrayFirst
導入バージョン: v1.1.0
`func(x[, y1, y2, ... yN])` が true を返すソース配列内の最初の要素を返します。該当する要素がない場合は、デフォルト値を返します。
**構文**
```sql theme={null}
arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) と条件配列 (`y`) の要素に対して動作するラムダ関数。[ラムダ関数](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source_arr` — 処理するソース配列。[`Array(T)`](/ja/reference/data-types/array)。 - `[, cond1_arr, ... , condN_arr]` — 省略可能。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)。
**戻り値**
`λ` が true になるソース配列の最初の要素を返します。該当する要素がない場合は、`T` のデフォルト値を返します。
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**該当なし**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
0 UInt8
```
## arrayFirstIndex
導入バージョン: v1.1.0
`func(x[, y1, y2, ... yN])` が true を返すソース配列内の最初の要素の索引を返します。該当する要素がない場合は '0' を返します。
**構文**
```sql theme={null}
arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) と条件配列 (`y`) の要素に対して評価を行うラムダ関数です。[Lambda function](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source_arr` — 処理対象のソース配列です。[`Array(T)`](/ja/reference/data-types/array)。 - `[, cond1_arr, ... , condN_arr]` — 省略可能。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/ja/reference/data-types/array)。
**戻り値**
`func` が true となるソース配列の最初の要素の索引を返します。該当する要素がない場合は `0` を返します [`UInt32`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
2
```
**一致するものはありません**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])
```
```response title=Response theme={null}
0
```
## arrayFirstOrNull
導入バージョン: v1.1.0
`func(x[, y1, y2, ... yN])` が true を返すソース配列内の最初の要素を返します。該当する要素がない場合は `NULL` を返します。
**構文**
```sql theme={null}
arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) および条件配列 (`y`) の要素に対して適用されるラムダ関数。[`Lambda function`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理するソース配列。[`Array(T)`](/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`func` が true となるソース配列の最初の要素を返します。該当する要素がない場合は `NULL` を返します。
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**該当なし**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
NULL Nullable(UInt8)
```
## arrayFlatten
導入バージョン: v20.1.0
配列の配列をフラット化して、1つの配列に変換します。
関数:
* ネストされた配列の深さにかかわらず適用できます。
* すでにフラットな配列は変更しません。
フラット化された配列には、すべてのソース配列の要素が含まれます。
**構文**
```sql theme={null}
arrayFlatten(arr)
```
**別名**: `flatten`
**引数**
* `arr` — 多次元配列。[`Array(Array(T))`](/ja/reference/data-types/array)
**戻り値**
多次元配列をフラット化した [`Array(T)`](/ja/reference/data-types/array) を返します
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayFlatten([[[1]], [[2], [3]]]);
```
```response title=Response theme={null}
[1, 2, 3]
```
## arrayFold
導入バージョン: v23.10.0
1 つ以上の同じ長さの配列にラムダ関数を適用し、その結果をアキュムレータに格納します。
**構文**
```sql theme={null}
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` が繰り返し再利用されます。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1 [, arr2, arr3, ... arrN]` — 演算の対象となる N 個の配列。[`Array(T)`](/ja/reference/data-types/array)
* `acc` — ラムダ関数の戻り値と同じ型のアキュムレータ値。
**戻り値**
最終的な `acc` の値を返します。
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;
```
```response title=Response theme={null}
23
```
**フィボナッチ数列**
```sql title=Query theme={null}
SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);
```
```response title=Response theme={null}
┌─fibonacci─┐
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 3 │
│ 5 │
│ 8 │
│ 13 │
│ 21 │
│ 34 │
└───────────┘
```
**複数のArrayを使用する例**
```sql title=Query theme={null}
SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;
```
```response title=Response theme={null}
300
```
## arrayIntersect
導入バージョン: v1.1.0
複数の配列を受け取り、すべてのソース配列に共通して含まれる要素からなる配列を返します。結果には一意の値のみが含まれます。
**構文**
```sql theme={null}
arrayIntersect(arr, arr1, ..., arrN)
```
**引数**
* `arrN` — 新しい配列の作成元となる N 個の配列。 [`Array(T)`](/ja/reference/data-types/array).
**戻り値**
N 個すべての配列に共通して含まれる重複のない要素からなる配列を返します [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
```
```response title=Response theme={null}
┌─empty_intersection─┬─non_empty_intersection─┐
│ [] │ [1] │
└────────────────────┴────────────────────────┘
```
## arrayJaccardIndex
導入バージョン: v23.7.0
2つの配列の [ジャカード係数](https://en.wikipedia.org/wiki/Jaccard_index) を返します。
**構文**
```sql theme={null}
arrayJaccardIndex(arr_x, arr_y)
```
**引数**
* `arr_x` — 1 つ目の配列。[`Array(T)`](/ja/reference/data-types/array)
* `arr_y` — 2 つ目の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`arr_x` と `arr_y` のジャカード係数を返します。[`Float64`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res
```
```response title=Response theme={null}
0.3333333333333333
```
## arrayJoin
導入バージョン: v1.1.0
`arrayJoin` 関数は、配列を含む1つの行を受け取り、それを展開して、配列の各要素ごとに1行ずつ、複数の行を生成します。
これは、同じ行の中で入力値を出力値に対応付ける ClickHouse の通常の関数や、
複数の行のグループを1つの要約行に「圧縮」または「集約」する集約関数
(`GROUP BY` とともに使用した場合は、要約行内の単一の値) とは対照的です。
この関数が適用されたカラムを除き、他のカラムの値はそのままコピーされます。
適用されたカラムの値は、対応する配列の要素の値に置き換えられます。
**構文**
```sql theme={null}
arrayJoin(arr)
```
**別名**: `unnest`
**引数**
* `arr` — 展開する配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`arr` を展開して得られる行の集合を返します。
**例**
**基本的な使い方**
```sql title=Query theme={null}
SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src
```
```response title=Response theme={null}
┌─dst─┬─\'Hello\'─┬─src─────┐
│ 1 │ Hello │ [1,2,3] │
│ 2 │ Hello │ [1,2,3] │
│ 3 │ Hello │ [1,2,3] │
└─────┴───────────┴─────────┘
```
**arrayJoin はクエリのすべての句に影響します**
```sql title=Query theme={null}
-- arrayJoin関数はWHERE句を含むクエリのすべてのセクションに影響します。サブクエリが返したのは1行ですが、結果が2になっていることに注目してください。
SELECT sum(1) AS impressions
FROM
(
SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];
```
```response title=Response theme={null}
┌─impressions─┐
│ 2 │
└─────────────┘
```
**複数の arrayJoin 関数を使用する**
```sql title=Query theme={null}
- 1つのクエリで複数のarrayJoin関数を使用できます。この場合、変換が複数回実行され、行数が乗算されます。
SELECT
sum(1) AS impressions,
arrayJoin(cities) AS city,
arrayJoin(browsers) AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 2 │ Istanbul │ Chrome │
│ 1 │ Istanbul │ Firefox │
│ 2 │ Berlin │ Chrome │
│ 1 │ Berlin │ Firefox │
│ 2 │ Bobruisk │ Chrome │
│ 1 │ Bobruisk │ Firefox │
└─────────────┴──────────┴─────────┘
```
**最適化によって予期しない結果が生じる場合**
```sql title=Query theme={null}
-- 同じ式に対して複数の arrayJoin を使用すると、最適化により期待どおりの結果が得られない場合があります。
-- このような場合は、JOIN の結果に影響しない追加の操作を加えて、繰り返し使用する配列式を変更することを検討してください。
- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))
SELECT
arrayJoin(dice) as first_throw,
/* arrayJoin(dice) as second_throw */ -- 技術的には正しいが、結果セットが消滅してしまう
arrayJoin(arrayConcat(dice, [])) as second_throw -- 再評価を強制するために意図的に式を変更している
FROM (
SELECT [1, 2, 3, 4, 5, 6] as dice
);
```
```response title=Response theme={null}
┌─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構文を使う**
```sql title=Query theme={null}
-- 以下の `SELECT` クエリの ARRAY JOIN 構文に注目してください。より幅広い用途に対応できます。
-- ARRAY JOIN を使用すると、要素数が同じ複数の配列を一度に変換できます。
SELECT
sum(1) AS impressions,
city,
browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
cities AS city,
browsers AS browser
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
```
**Tupleの使用**
```sql title=Query theme={null}
-- Tupleを使用することもできます
SELECT
sum(1) AS impressions,
(arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
t.2 AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
```
## arrayLast
導入バージョン: v1.1.0
ラムダ `func(x [, y1, y2, ... yN])` が true を返すソース配列内の最後の要素を返します。該当する要素がない場合は、デフォルト値を返します。
**構文**
```sql theme={null}
arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) および条件配列 (`y`) の要素に対して適用されるラムダ関数です。[Lambda function](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source` — 処理対象のソース配列。[`Array(T)`](/ja/reference/data-types/array)。 - `[, cond1, ... , condN]` — 省略可。ラムダ関数に追加の引数を渡すための N 個の条件配列です。[`Array(T)`](/ja/reference/data-types/array)。
**戻り値**
`func` が true となるソース配列内の最後の要素を返します。該当する要素がない場合は、`T` のデフォルト値を返します。
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**該当なし**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
0 UInt8
```
## arrayLastIndex
導入バージョン: v1.1.0
`func(x[, y1, y2, ... yN])` が true を返すソース配列内の最後の要素の索引を返します。該当する要素がない場合は '0' を返します。
**構文**
```sql theme={null}
arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) と条件配列 (`y`) の要素に対して評価を行うラムダ関数。[`Lambda function`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 省略可能。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`func` が true となるソース配列の最後の要素の索引を返します。該当する要素がない場合は `0` を返します。 [`UInt32`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);
```
```response title=Response theme={null}
3
```
**該当なし**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);
```
```response title=Response theme={null}
0
```
## arrayLastOrNull
導入バージョン: v1.1.0
ラムダ `func(x [, y1, y2, ... yN])` が true を返すソース配列内の最後の要素を返します。該当する要素がない場合は、`NULL` を返します。
**構文**
```sql theme={null}
arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x [, y1, ..., yN])` — ソース配列 (`x`) と条件配列 (`y`) の要素に対して適用されるラムダ関数です。[ラムダ関数](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source_arr` — 処理対象のソース配列。[`Array(T)`](/ja/reference/data-types/array)。 - `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)。
**戻り値**
`λ` が真ではないソース配列内の最後の要素を返します。該当する要素がない場合は `NULL` を返します。
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**該当なし**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
NULL Nullable(UInt8)
```
## arrayLevenshteinDistance
導入バージョン: v25.4.0
2つの配列のレーベンシュタイン距離を計算します。
**構文**
```sql theme={null}
arrayLevenshteinDistance(from, to)
```
**引数**
* `from` — 1 つ目の配列。[`Array(T)`](/ja/reference/data-types/array)。 - `to` — 2 つ目の配列。[`Array(T)`](/ja/reference/data-types/array)。
**戻り値**
1 つ目と 2 つ目の配列の間のレーベンシュタイン距離。[`Float64`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])
```
```response title=Response theme={null}
1
```
## arrayLevenshteinDistanceWeighted
導入バージョン: v25.4.0
各要素にカスタムの重みを設定した、2つのArrayのレーベンシュタイン距離を計算します。
Arrayとその重みの要素数は一致している必要があります。
**構文**
```sql theme={null}
arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)
```
**引数**
* `from` — 第1の配列。[`Array(T)`](/ja/reference/data-types/array)。 - `to` — 第2の配列。[`Array(T)`](/ja/reference/data-types/array)。 - `from_weights` — 第1の配列の重み。[`Array((U)Int*|Float*)`](/ja/reference/data-types/array)
* `to_weights` — 第2の配列の重み。[`Array((U)Int*|Float*)`](/ja/reference/data-types/array)
**戻り値**
各要素にカスタム重みを設定した、第1および第2の配列間のレーベンシュタイン距離。[`Float64`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])
```
```response title=Response theme={null}
14
```
## arrayMap
導入バージョン: v1.1.0
元の配列の各要素にラムダ関数を適用して得られる配列を返します。
**構文**
```sql theme={null}
arrayMap(func, arr)
```
**引数**
* `func` — ソース配列 (`x`) と条件配列 (`y`) の要素に適用されるラムダ関数です。[`Lambda function`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — 処理対象の配列を N 個指定します。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ラムダ関数の結果からなる配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
```
```response title=Response theme={null}
[3, 4, 5]
```
**異なる配列の要素からタプルを作成する**
```sql title=Query theme={null}
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
```
```response title=Response theme={null}
[(1, 4),(2, 5),(3, 6)]
```
## arrayMax
導入バージョン: v21.1.0
ソース配列内の最大の要素を返します。
ラムダ関数 `func` が指定されている場合は、その評価結果の最大値を返します。
**構文**
```sql theme={null}
arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — 任意。ソース配列 (`x`) と条件配列 (`y`) の要素に対して処理を行うラムダ関数です。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列です。[`Array(T)`](/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列内の最大要素を返します。ラムダ関数が指定されている場合は、ラムダ関数の結果の最大要素を返します。
**例**
**基本例**
```sql title=Query theme={null}
SELECT arrayMax([5, 3, 2, 7]);
```
```response title=Response theme={null}
7
```
**ラムダ関数の使用例**
```sql title=Query theme={null}
SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
12
```
## arrayMin
導入バージョン: v21.1.0
ソース配列内の最小要素を返します。
ラムダ関数 `func` が指定されている場合は、ラムダ関数の結果のうち最小の要素を返します。
**構文**
```sql theme={null}
arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — オプション。ソース配列 (`x`) および条件配列 (`y`) の要素に対して処理を行うラムダ関数。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/ja/reference/data-types/array)
* `cond1_arr, ...` — オプション。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列内の最小要素を返します。ラムダ関数が指定されている場合は、その結果の最小要素を返します。
**例**
**基本例**
```sql title=Query theme={null}
SELECT arrayMin([5, 3, 2, 7]);
```
```response title=Response theme={null}
2
```
**ラムダ関数での使用**
```sql title=Query theme={null}
SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
4
```
## arrayNormalizedGini
導入バージョン: v25.1.0
正規化ジニ係数を計算します。
**構文**
```sql theme={null}
arrayNormalizedGini(predicted, label)
```
**引数**
* `predicted` — 予測値。[`Array(T)`](/ja/reference/data-types/array)
* `label` — 正解値。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
予測値のジニ係数、正規化値のジニ係数、および正規化ジニ係数 (= 前者2つのジニ係数の比) を含むタプル。[`Tuple(Float64, Float64, Float64)`](/ja/reference/data-types/tuple)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);
```
```response title=Response theme={null}
(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)
```
## arrayPartialReverseSort
導入バージョン: v23.2.0
この関数は `arrayReverseSort` と同じですが、`limit` 引数を追加することで部分ソートを行えます。
ソート済みの要素のみを残すには、`arrayResize` を使用します。
**構文**
```sql theme={null}
arrayPartialReverseSort([f,] arr [, arr1, ... ,arrN], limit)
```
**引数**
* `f(arr[, arr1, ... ,arrN])` — 配列 `x` の要素に適用するラムダ関数。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — ソート対象の配列。[`Array(T)`](/ja/reference/data-types/array)
* `arr1, ... ,arrN` — `f` が複数の引数を受け取る場合に指定する、追加の N 個の配列。[`Array(T)`](/ja/reference/data-types/array)
* `limit` — どこまでソートするかを示す索引値。[`(U)Int*`](/ja/reference/data-types/int-uint)
**戻り値**
元の配列と同じサイズの配列を返します。この配列では、範囲 `[1..limit]` の要素が
降順にソートされます。残りの要素 `(limit..N]` の順序は未規定です。
**例**
**simple\_int**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])
```
```response title=Response theme={null}
['lasso','gladly','expenses','embolism']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[9, 5]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[0, 1, 2]
```
## arrayPartialShuffle
導入バージョン: v23.2.0
元の配列と同じサイズの配列を返します。この配列では、`[1..limit]` の範囲の要素が元の配列からランダムに選ばれた
部分集合となります。残りの `(limit..n]` には、`[1..limit]` に含まれない要素が未定義の順序で格納されます。
`limit` の値は `[1..n]` の範囲内である必要があります。この範囲外の値を指定した場合は、完全な `arrayShuffle` を実行するのと同等です。
この関数は定数をマテリアライズしません。
`limit` の値は `[1..N]` の範囲内である必要があります。この範囲外の値を指定した場合は、完全な [`arrayShuffle`](#arrayShuffle) を実行するのと同等です。
**構文**
```sql theme={null}
arrayPartialShuffle(arr [, limit[, seed]])
```
**引数**
* `arr` — シャッフルする配列。[`Array(T)`](/ja/reference/data-types/array)
* `seed` — 任意。乱数生成に使用するシード値です。指定しない場合はランダムな値が使用されます。[`(U)Int*`](/ja/reference/data-types/int-uint)
* `limit` — 任意。要素の入れ替え回数を `[1..N]` の範囲に制限するための数値です。[`(U)Int*`](/ja/reference/data-types/int-uint)
**戻り値**
要素の一部がシャッフルされた Array。[`Array(T)`](/ja/reference/data-types/array)
**例**
**no\_limit1**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 0)
```
```response title=Response theme={null}
[2, 4, 3, 1]
```
**no\_limit2**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4])
```
```response title=Response theme={null}
[4, 1, 3, 2]
```
**random\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2)
```
```response title=Response theme={null}
[3, 4, 1, 2]
```
**explicit\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)
```
```response title=Response theme={null}
[3, 2, 1, 4]
```
**マテリアライズ**
```sql title=Query theme={null}
SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)
```
```response title=Response theme={null}
┌─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` を使用します。
**構文**
```sql theme={null}
arrayPartialSort([f,] arr [, arr1, ... ,arrN], limit)
```
**引数**
* `f(arr[, arr1, ... ,arrN])` — 配列 `x` の要素に適用するラムダ関数です。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — ソートする Array です。[`Array(T)`](/ja/reference/data-types/array)
* `arr1, ... ,arrN` — `f` が複数の引数を受け取る場合に使用する、追加の N 個の配列です。[`Array(T)`](/ja/reference/data-types/array)
* `limit` — ソートを行う範囲の終端を表すインデックス値です。[`(U)Int*`](/ja/reference/data-types/int-uint)
**戻り値**
元の配列と同じサイズの配列を返します。この配列では、範囲 `[1..limit]` の要素が
昇順にソートされます。残りの要素 `(limit..N]` の順序は未定です。
**例**
**simple\_int**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])
```
```response title=Response theme={null}
['embolism', 'expenses', 'gladly', 'lasso']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[1, 3]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[2, 1, 0]
```
## arrayPopBack
導入バージョン: v1.1.0
配列の最後の要素を削除します。
**構文**
```sql theme={null}
arrayPopBack(arr)
```
**引数**
* `arr` — 末尾の要素を削除する配列です。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`arr` と同じ配列から末尾の要素を取り除いた配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayPopBack([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[1, 2]
```
## arrayPopFront
導入バージョン: v1.1.0
配列の先頭の要素を取り除きます。
**構文**
```sql theme={null}
arrayPopFront(arr)
```
**引数**
* `arr` — 先頭の要素を削除する配列です。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`arr` と同じですが、`arr` の先頭要素を除いた配列を返します [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayPopFront([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[2, 3]
```
## arrayProduct
導入バージョン: v21.1.0
ソース配列内の要素の積を返します。
ラムダ関数 `func` が指定されている場合は、そのラムダ関数の結果の各要素の積を返します。
**構文**
```sql theme={null}
arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — 任意。ソース配列 (`x`) と条件配列 (`y`) の要素に対して処理を行うラムダ関数。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列の要素の積、または指定されている場合はラムダ関数の結果要素の積を返します。[`Float64`](/ja/reference/data-types/float)
**例**
**基本例**
```sql title=Query theme={null}
SELECT arrayProduct([1, 2, 3, 4]);
```
```response title=Response theme={null}
24
```
**ラムダ関数での使用**
```sql title=Query theme={null}
SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;
```
```response title=Response theme={null}
16
```
## arrayPushBack
導入バージョン: v1.1.0
配列の末尾に要素を 1 つ追加します。
**構文**
```sql theme={null}
arrayPushBack(arr, x)
```
**引数**
* `arr` — 末尾に値 `x` を追加する対象の配列です。[`Array(T)`](/ja/reference/data-types/array)
* `x` —
* 配列の末尾に追加する単一の値です。[`Array(T)`](/ja/reference/data-types/array)。
- 数値の配列に追加できるのは数値のみで、文字列の配列に追加できるのは文字列のみです。
- 数値を追加する場合、ClickHouse は配列のデータ型に合わせて `x` の型を自動的に設定します。
- `NULL` を指定できます。この関数は配列に `NULL` 要素を追加し、配列要素の型は `Nullable` に変換されます。
ClickHouse のデータ型について詳しくは、[Data types](/ja/reference/data-types) を参照してください。
**戻り値**
`arr` と同じ内容で、配列の末尾に追加の値 `x` が加わった配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayPushBack(['a'], 'b') AS res;
```
```response title=Response theme={null}
['a','b']
```
## arrayPushFront
導入バージョン: v1.1.0
配列の先頭に要素を 1 つ追加します。
**構文**
```sql theme={null}
arrayPushFront(arr, x)
```
**Arguments**
* `arr` — 末尾に値 `x` を追加する対象の配列です。[`Array(T)`](/ja/reference/data-types/array)。 - `x` —
* 配列の先頭に追加する単一の値です。[`Array(T)`](/ja/reference/data-types/array)。
- 数値の配列には数値のみ、文字列の配列には文字列のみを追加できます。
- 数値を追加する場合、ClickHouse は配列のデータ型に合わせて `x` の型を自動的に設定します。
- `NULL` も指定できます。この関数は配列に `NULL` 要素を追加し、配列要素の型は `Nullable` に変換されます。
ClickHouse のデータ型の詳細については、[Data types](/ja/reference/data-types) を参照してください。
**戻り値**
`arr` と同一ですが、配列の先頭に追加の値 `x` が含まれる配列を返します [`Array(T)`](/ja/reference/data-types/array)
**Examples**
**Usage example**
```sql title=Query theme={null}
SELECT arrayPushFront(['b'], 'a') AS res;
```
```response title=Response theme={null}
['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 とも呼ばれます) は、機械学習における概念です。
詳細については、[こちら](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve)、[こちら](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1)、および[こちら](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve)を参照してください。
**構文**
```sql theme={null}
arrayROCAUC(scores, labels[, scale[, partial_offsets]])
```
**別名**: `arrayAUC`
**引数**
* `scores` — 予測モデルが出力するスコア。[`Array((U)Int*)`](/ja/reference/data-types/array) または [`Array(Float*)`](/ja/reference/data-types/array)
* `labels` — サンプルのラベル。通常、正例には 1、負例には 0 を使用します。[`Array((U)Int*)`](/ja/reference/data-types/array) または [`Enum`](/ja/reference/data-types/enum)
* `scale` — 任意。正規化された面積を返すかどうかを指定します。false の場合は、代わりに TP (真陽性) x FP (偽陽性) 曲線の下の面積を返します。デフォルト値: true。[`Bool`](/ja/reference/data-types/boolean)
* `partial_offsets` —
* AUC 全体ではなく ROC 曲線の部分面積 (ROC 空間の縦方向の帯に相当) を計算するための、4 つの非負整数からなる配列です。このオプションは、ROC AUC の分散計算に役立ちます。配列には次の要素を含める必要があります: \[`higher_partitions_tp`, `higher_partitions_fp`, `total_positives`, `total_negatives`]。[Array](/ja/reference/data-types/array) の非負の [Integers](/ja/reference/data-types/int-uint)。任意です。
* `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`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
0.75
```
## arrayRandomSample
導入バージョン: v23.10.0
入力配列から、ランダムに選択した `samples` 個の要素からなる部分集合を返します。`samples` が入力配列のサイズを超える場合、サンプル数は配列のサイズに制限されます。つまり、配列のすべての要素が返されますが、その順序は保証されません。この関数は、フラットな配列とネストされた配列の両方を扱えます。
**構文**
```sql theme={null}
arrayRandomSample(arr, samples)
```
**引数**
* `arr` — 要素をサンプリングする対象の入力配列、または多次元配列です。[`Array(T)`](/ja/reference/data-types/array)
* `samples` — ランダムサンプルに含める要素数です。[`(U)Int*`](/ja/reference/data-types/int-uint)
**戻り値**
入力配列からランダムに抽出した要素のサンプルを含む配列 [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;
```
```response title=Response theme={null}
['cherry','apple']
```
**多次元配列を使用する**
```sql title=Query theme={null}
SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;
```
```response title=Response theme={null}
[[3,4],[5,6]]
```
## arrayReduce
導入バージョン: v1.1.0
配列要素に集約関数を適用し、その結果を返します。
集約関数の名前は、`'max'`、`'sum'` のようにシングルクォートで囲んだ文字列として渡します。
パラメトリック集約関数を使用する場合、パラメータは `'uniqUpTo(6)'` のように関数名の後のかっこ内で指定します。
**構文**
```sql theme={null}
arrayReduce(agg_f, arr1[, arr2, ... , arrN])
```
**引数**
* `agg_f` — 定数で指定する集約関数の名前。[`String`](/ja/reference/data-types/string)
* `arr1[, arr2, ... , arrN]` — `agg_f` の引数に対応する N 個の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
集約関数の結果を返します
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayReduce('max', [1, 2, 3]);
```
```response title=Response theme={null}
┌─arrayReduce('max', [1, 2, 3])─┐
│ 3 │
└───────────────────────────────┘
```
**複数の引数を使用する集約関数の例**
```sql title=Query theme={null}
--集計関数が複数の引数を取る場合、この関数は同じサイズの複数のArrayに適用する必要があります。
SELECT arrayReduce('maxIf', [3, 5], [1, 0]);
```
```response title=Response theme={null}
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│ 3 │
└──────────────────────────────────────┘
```
**パラメトリック集約関数の例**
```sql title=Query theme={null}
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
```
```response title=Response theme={null}
┌─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), ...)` を複数回実行した場合と同じ結果を返します。
**構文**
```sql theme={null}
arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])
```
**引数**
* `agg_f` — 使用する aggregate function の名前。[`String`](/ja/reference/data-types/string)
* `ranges` — 集約する範囲。集約を開始する索引 `i` と、集約対象の範囲 `r` を含む `(i, r)` 形式の Tuple の配列。[`Array(T)`](/ja/reference/data-types/array) または [`Tuple(T)`](/ja/reference/data-types/tuple)
* `arr1[, arr2, ... ,arrN]` — aggregate function に渡す N 個の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
指定した範囲に対する aggregate function の結果を含む配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayReduceInRanges(
'sum',
[(1, 5), (2, 3), (3, 4), (4, 4)],
[1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
```
```response title=Response theme={null}
┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘
```
## arrayRemove
導入バージョン: v25.11.0
配列から、指定した値と等しい要素をすべて削除します。
NULL は等しいものとして扱われます。
**構文**
```sql theme={null}
arrayRemove(arr, elem)
```
**別名**: `array_remove`
**引数**
* `arr` — Array(T) - `elem` — T
**戻り値**
ソース配列のサブセット [`Array(T)`](/ja/reference/data-types/array) を返します
**例**
**例 1**
```sql title=Query theme={null}
SELECT arrayRemove([1, 2, 2, 3], 2)
```
```response title=Response theme={null}
[1, 3]
```
**例 2**
```sql title=Query theme={null}
SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)
```
```response title=Response theme={null}
['a', 'b']
```
## arrayResize
導入バージョン: v1.1.0
配列の長さを変更します。
**構文**
```sql theme={null}
arrayResize(arr, size[, extender])
```
**引数**
* `arr` — リサイズ対象の Array。[`Array(T)`](/ja/reference/data-types/array)
* `size` —
-Array の新しい長さ。
`size` が Array の元のサイズより小さい場合、Array は右側から切り詰められます。
`size` が Array の初期サイズより大きい場合、Array は右側に `extender` の値、または Array 要素のデータ型のデフォルト値で拡張されます。
* `extender` — Array の拡張に使用する値。`NULL` を指定できます。
**戻り値**
長さが `size` の Array。[`Array(T)`](/ja/reference/data-types/array)
**例**
**例 1**
```sql title=Query theme={null}
SELECT arrayResize([1], 3);
```
```response title=Response theme={null}
[1,0,0]
```
**例 2**
```sql title=Query theme={null}
SELECT arrayResize([1], 3, NULL);
```
```response title=Response theme={null}
[1,NULL,NULL]
```
## arrayReverse
導入バージョン: v1.1.0
指定された配列の要素の並び順を逆にします。
関数 `reverse(arr)` も同じ機能を持ち、Array に加えて他のデータ型にも対応しています。
**構文**
```sql theme={null}
arrayReverse(arr)
```
**引数**
* `arr` — 反転する配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
元の配列と同じサイズで、要素が逆順に並んだ配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayReverse([1, 2, 3])
```
```response title=Response theme={null}
[3,2,1]
```
## arrayReverseFill
導入バージョン: v20.1.0
`arrayReverseFill` 関数は、ソース配列を末尾の
要素から先頭の要素へ順に処理し、各位置でソース配列および条件配列の要素を使って
ラムダ条件を評価します。位置 i で条件の評価結果が false の場合、
この関数はその要素を、配列の現在の状態における位置 i+1 の要素で
置き換えます。最後の要素は、条件にかかわらず
常に保持されます。
**構文**
```sql theme={null}
arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) と条件配列 (`y`) の要素に対して動作するラムダ関数です。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列です。[`Array(T)`](/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意です。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列の各要素がラムダ関数の結果に置き換えられた配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**単一の配列を使った例**
```sql title=Query theme={null}
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 2, 2, NULL]
```
**2つの配列を使った例**
```sql title=Query theme={null}
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 title=Response theme={null}
[5, 6, 6, 2]
```
## arrayReverseSort
導入バージョン: v1.1.0
配列の要素を降順にソートします。
関数 `f` が指定されている場合、指定した配列は、その配列要素に関数を適用した結果に基づいてソートされた後、反転されます。
`f` が複数の引数を受け取る場合、`arrayReverseSort` 関数には複数の配列が渡され、これらは `func` の各引数に対応します。
ソート対象の配列に `-Inf`、`NULL`、`NaN`、または `Inf` が含まれている場合、これらは次の順序でソートされます。
1. `-Inf`
2. `Inf`
3. `NaN`
4. `NULL`
`arrayReverseSort` は[高階関数](/ja/reference/functions/regular-functions/overview#higher-order-functions)です。
**構文**
```sql theme={null}
arrayReverseSort([f,] arr [, arr1, ... ,arrN)
```
**引数**
* `f(y1[, y2 ... yN])` — 配列 `x` の要素に適用するラムダ関数。 - `arr` — ソートする配列。 [`Array(T)`](/ja/reference/data-types/array) - `arr1, ..., yN` — 任意。`f` が複数の引数を受け取る場合に指定する、追加の N 個の配列。
**戻り値**
ラムダ関数が指定されていない場合は、配列 `x` を降順にソートして返します。指定されている場合は、
指定されたラムダ関数のロジックに従って配列をソートし、その後で反転した配列を返します。 [`Array(T)`](/ja/reference/data-types/array)。
**例**
**例 1**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
```
```response title=Response theme={null}
[5,3,4]
```
**例 2**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
```
```response title=Response theme={null}
[4,3,5]
```
## arrayReverseSplit
導入バージョン: v20.1.0
ソース配列を複数の配列に分割します。`func(x[, y1, ..., yN])` が 0 以外の値を返した場合、その要素の右側で配列が分割されます。最後の要素の後では分割されません。
**構文**
```sql theme={null}
arrayReverseSplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) および条件配列 (`y`) の要素に対して処理を行うラムダ関数です。[`Lambda function`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列です。[`Lambda function`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
配列の配列を返します。[`Array(Array(T))`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[1], [2, 3, 4], [5]]
```
## arrayRotateLeft
導入バージョン: v23.8.0
配列を、指定した要素数だけ左に回転します。`n` の値が負の場合は、回転量の絶対値だけ右に回転するものとして扱われます。
**構文**
```sql theme={null}
arrayRotateLeft(arr, n)
```
**引数**
* `arr` — 要素を回転させる対象の配列。[`Array(T)`](/ja/reference/data-types/array)。 - `n` — 回転させる要素数。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint)。
**戻り値**
指定した要素数だけ左に回転された配列 [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,1,2]
```
**n が負の値の場合**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[5,6,1,2,3,4]
```
## arrayRotateRight
導入バージョン: v23.8.0
配列を、指定した要素数だけ右に回転します。`n` が負の値の場合は、その絶対値の分だけ左に回転するものとして扱われます。
**構文**
```sql theme={null}
arrayRotateRight(arr, n)
```
**引数**
* `arr` — 要素をローテーションする配列。[`Array(T)`](/ja/reference/data-types/array)。 - `n` — ローテーションする要素の数。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint)。
**戻り値**
指定した数だけ右にローテーションされた配列 [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[5,6,1,2,3,4]
```
**n が負の値の場合**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[3,4,5,6,1,2]
```
## arrayShiftLeft
導入バージョン: v23.8.0
指定した要素数だけ配列を左にシフトします。
新しい要素は、指定された引数または配列の要素型のデフォルト値で埋められます。
要素数が負の場合、配列は右にシフトされます。
**構文**
```sql theme={null}
arrayShiftLeft(arr, n[, default])
```
**引数**
* `arr` — 要素をシフトする配列。[`Array(T)`](/ja/reference/data-types/array)。 - `n` — シフトする要素数。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint)。 - `default` — 任意。新たに追加される要素のデフォルト値。
**戻り値**
指定した数の要素だけ左にシフトされた配列 [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,0,0]
```
**n が負の値の場合**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[0,0,1,2,3,4]
```
**デフォルト値を使用する**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;
```
```response title=Response theme={null}
[3,4,5,6,42,42]
```
## arrayShiftRight
導入バージョン: v23.8.0
配列を指定した要素数だけ右にシフトします。
新しい要素は、指定した引数または配列の要素型のデフォルト値で埋められます。
要素数が負の場合、配列は左にシフトされます。
**構文**
```sql theme={null}
arrayShiftRight(arr, n[, default])
```
**引数**
* `arr` — 要素をシフトする対象の配列です。[`Array(T)`](/ja/reference/data-types/array)
* `n` — シフトする要素の数です。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint)
* `default` — 省略可。新しく作成される要素のデフォルト値です。
**戻り値**
指定した要素数だけ右にシフトされた配列です。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;
```
```response title=Response theme={null}
[0, 0, 1, 2, 3, 4]
```
**n が負の値の場合**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;
```
```response title=Response theme={null}
[3, 4, 5, 6, 0, 0]
```
**デフォルト値を使用する**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;
```
```response title=Response theme={null}
[42, 42, 1, 2, 3, 4]
```
## arrayShingles
導入バージョン: v24.1.0
シングルの配列 (文字列に対するN-gramに類似) を生成します。つまり、入力配列から指定した長さの連続した部分配列を生成します。
**構文**
```sql theme={null}
arrayShingles(arr, l)
```
**引数**
* `arr` — shingle の配列を生成する対象の Array。[`Array(T)`](/ja/reference/data-types/array)
* `l` — 各 shingle の長さ。[`(U)Int*`](/ja/reference/data-types/int-uint)
**戻り値**
生成された shingle の配列 [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayShingles([1, 2, 3, 4], 3) as res;
```
```response title=Response theme={null}
[[1, 2, 3], [2, 3, 4]]
```
## arrayShuffle
導入バージョン: v23.2.0
元の配列と同じサイズで、要素がシャッフルされた順序で格納された配列を返します。
要素は、考えられるすべての順列が同じ確率で現れるように並べ替えられます。
この関数では定数はマテリアライズされません。
**構文**
```sql theme={null}
arrayShuffle(arr [, seed])
```
**引数**
* `arr` — シャッフルする配列です。[`Array(T)`](/ja/reference/data-types/array)
* `seed (optional)` — 省略可能です。乱数生成に使用するシード値です。指定しない場合は、ランダムな値が使用されます。[`(U)Int*`](/ja/reference/data-types/int-uint)
**戻り値**
要素をシャッフルした Array [`Array(T)`](/ja/reference/data-types/array)
**例**
**seed を指定しない例 (結果は不安定) **
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4]);
```
```response title=Response theme={null}
[1,4,2,3]
```
**seed なしの例 (安定した結果) **
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4], 41);
```
```response title=Response theme={null}
[3,2,1,4]
```
## arraySimilarity
導入バージョン: v25.4.0
重み付きレーベンシュタイン距離に基づいて、2 つの配列の類似度を `0` から `1` の範囲で計算します。
**構文**
```sql theme={null}
arraySimilarity(from, to, from_weights, to_weights)
```
**引数**
* `from` — 1つ目の配列 [`Array(T)`](/ja/reference/data-types/array)
* `to` — 2つ目の配列 [`Array(T)`](/ja/reference/data-types/array)
* `from_weights` — 1つ目の配列の重み。 [`Array((U)Int*|Float*)`](/ja/reference/data-types/array)
* `to_weights` — 2つ目の配列の重み。 [`Array((U)Int*|Float*)`](/ja/reference/data-types/array)
**戻り値**
重み付きレーベンシュタイン距離に基づく、2つの配列間の `0` から `1` の類似度を返します [`Float64`](/ja/reference/data-types/float)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);
```
```response title=Response theme={null}
0.2222222222222222
```
## arraySlice
導入バージョン: v1.1.0
配列の一部を返します。`NULL` 要素も含まれます。
**構文**
```sql theme={null}
arraySlice(arr, offset [, length])
```
**引数**
* `arr` — スライス対象の Array。[`Array(T)`](/ja/reference/data-types/array)
* `offset` — 配列の端からの位置。正の値は左側からのオフセット、負の値は右側からのインデントを示します。配列要素の番号は `1` から始まります。[`(U)Int*`](/ja/reference/data-types/int-uint)
* `length` — 必要なスライスの長さ。負の値を指定すると、関数は開区間のスライス `[offset, array_length - length]` を返します。値を省略すると、関数はスライス `[offset, the_end_of_array]` を返します。[`(U)Int*`](/ja/reference/data-types/int-uint)
**戻り値**
指定した `offset` から `length` 個の要素を含む配列のスライスを返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
```
```response title=Response theme={null}
[2, NULL, 4]
```
## arraySort
導入バージョン: v1.1.0
指定された配列の要素を昇順にソートします。
ラムダ関数 `f` が指定されている場合、ソート順は
配列の各要素にラムダを適用した結果によって決まります。
ラムダが複数の引数を受け取る場合、`arraySort` 関数には複数の
配列が渡され、それぞれが `f` の引数に対応します。
ソート対象の配列に `-Inf`、`NULL`、`NaN`、または `Inf` が含まれている場合、これらは次の順序でソートされます。
1. `-Inf`
2. `Inf`
3. `NaN`
4. `NULL`
`arraySort` は[高階関数](/ja/reference/functions/regular-functions/overview#higher-order-functions)です。
**構文**
```sql theme={null}
arraySort([f,] arr [, arr1, ... ,arrN])
```
**引数**
* `f(y1[, y2 ... yN])` — 配列 `x` の要素に適用するラムダ関数。 - `arr` — ソートする配列。 [`Array(T)`](/ja/reference/data-types/array) - `arr1, ..., yN` — 任意。`f` が複数の引数を受け取る場合に指定する、追加の N 個の配列。
**戻り値**
ラムダ関数が指定されていない場合は、配列 `arr` を昇順にソートして返します。
指定されている場合は、指定されたラムダ関数のロジックに従ってソートされた配列を返します。 [`Array(T)`](/ja/reference/data-types/array).
**例**
**例 1**
```sql title=Query theme={null}
SELECT arraySort([1, 3, 3, 0]);
```
```response title=Response theme={null}
[0,1,3,3]
```
**例 2**
```sql title=Query theme={null}
SELECT arraySort(['hello', 'world', '!']);
```
```response title=Response theme={null}
['!','hello','world']
```
**例 3**
```sql title=Query theme={null}
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
```
```response title=Response theme={null}
[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]
```
## arraySplit
導入バージョン: v20.1.0
ソース配列を複数の配列に分割します。`func(x [, y1, ..., yN])` が 0 以外の値を返した場合、その要素の左側で配列が分割されます。最初の要素の前では配列は分割されません。
**構文**
```sql theme={null}
arraySplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — ソース配列 (`x`) および条件配列 (`y`) の要素に対して適用されるラムダ関数です。[ラムダ関数](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source_arr` — 分割対象のソース配列 [`Array(T)`](/ja/reference/data-types/array)。 - `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。 [`Array(T)`](/ja/reference/data-types/array)。
**戻り値**
配列の配列を返します [`Array(Array(T))`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[1, 2, 3], [4, 5]]
```
## arraySum
導入バージョン: v21.1.0
ソース配列内の要素の合計を返します。
ラムダ関数 `func` が指定されている場合は、ラムダ関数の結果の合計を返します。
**構文**
```sql theme={null}
arraySum([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**引数**
* `func(x[, y1, ..., yN])` — 任意。ソース配列 (`x`) と条件配列 (`y`) の要素に対して処理を行うラムダ関数。[`ラムダ関数`](/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/ja/reference/data-types/array)
* `, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列の要素の合計、または指定した場合はラムダ関数の結果要素の合計を返します。
**例**
**基本例**
```sql title=Query theme={null}
SELECT arraySum([1, 2, 3, 4]);
```
```response title=Response theme={null}
10
```
**ラムダ関数を使った使用方法**
```sql title=Query theme={null}
SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);
```
```response title=Response theme={null}
8
```
## arraySymmetricDifference
導入バージョン: v25.4.0
複数の配列を受け取り、すべてのソース配列に共通して存在するわけではない要素からなる配列を返します。結果には一意の値のみが含まれます。
*2 つを超える集合*の対称差は、[数学的には](https://en.wikipedia.org/wiki/Symmetric_difference#n-ary_symmetric_difference)
奇数個の入力集合に現れるすべての入力要素からなる集合として定義されます。
一方、関数 `arraySymmetricDifference` は、すべての入力集合に共通して存在するわけではない入力要素の集合を単純に返します。
**構文**
```sql theme={null}
arraySymmetricDifference(arr1, arr2, ... , arrN)
```
**引数**
* `arrN` — 新しい配列の作成元となる N 個の配列。[`Array(T)`](/ja/reference/data-types/array)。
**戻り値**
すべてのソース配列に共通して含まれない、重複のない要素からなる配列を返します [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ [] │ [3,2] │
└────────────────────────────┴────────────────────────────────┘
```
## arrayTranspose
導入バージョン: v26.4.0
二次元配列を転置します。
すべての内部配列は同じ長さである必要があります。
**構文**
```sql theme={null}
arrayTranspose(arr)
```
**引数**
* `arr` — 転置する二次元配列。すべての内部配列は同じ長さである必要があります。[`Array(Array(T))`](/ja/reference/data-types/array)
**戻り値**
結果の要素 `[i][j]` が入力の要素 `[j][i]` に等しくなる、転置後の二次元配列。[`Array(Array(T))`](/ja/reference/data-types/array)
**例**
**正方行列**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2], [3, 4]])
```
```response title=Response theme={null}
[[1, 3], [2, 4]]
```
**非正方行列**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])
```
```response title=Response theme={null}
[[1, 4], [2, 5], [3, 6]]
```
**文字列型の要素**
```sql title=Query theme={null}
SELECT arrayTranspose([['a', 'b'], ['c', 'd']])
```
```response title=Response theme={null}
[['a', 'c'], ['b', 'd']]
```
## arrayUnion
導入バージョン: v24.10.0
複数の配列を受け取り、いずれかのソース配列に含まれるすべての要素から成る配列を返します。結果には一意の値のみが含まれます。
**構文**
```sql theme={null}
arrayUnion(arr1, arr2, ..., arrN)
```
**引数**
* `arrN` — 新しい配列の作成元となる N 個の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列内の一意な要素からなる配列を返します [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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)` を使用できます。
**構文**
```sql theme={null}
arrayUniq(arr1[, arr2, ..., arrN])
```
**引数**
* `arr1` — 一意な要素数を数える対象の Array。 [`Array(T)`](/ja/reference/data-types/array)
* `[, arr2, ..., arrN]` — 任意。複数の Array の対応する位置にある要素から構成される、一意な Tuple の数を数えるための追加の Array。 [`Array(T)`](/ja/reference/data-types/array)
**戻り値**
引数が 1 つの場合は、一意な
要素数を返します。引数が複数ある場合は、各 Array の対応する位置にある要素から構成される一意な Tuple の数を返します。
[`UInt32`](/ja/reference/data-types/int-uint)
**例**
**単一引数**
```sql title=Query theme={null}
SELECT arrayUniq([1, 1, 2, 2])
```
```response title=Response theme={null}
2
```
**複数の引数**
```sql title=Query theme={null}
SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])
```
```response title=Response theme={null}
3
```
## arrayWithConstant
導入バージョン: v20.1.0
定数 `x` で埋めた長さ `length` の配列を作成します。
**構文**
```sql theme={null}
arrayWithConstant(N, x)
```
**引数**
* `length` — 配列の要素数。[`(U)Int*`](/ja/reference/data-types/int-uint)
* `x` — 配列の `N` 個の要素の値。型は任意です。
**戻り値**
値 `x` の `N` 個の要素で構成される Array を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayWithConstant(3, 1)
```
```response title=Response theme={null}
[1, 1, 1]
```
## arrayZip
導入バージョン: v20.1.0
複数の配列を 1 つの配列に結合します。結果の配列には、ソース配列の対応する要素が、引数に記載された順序でタプルにまとめられて格納されます。
**構文**
```sql theme={null}
arrayZip(arr1, arr2, ... , arrN)
```
**引数**
* `arr1, arr2, ... , arrN` — 1 つの配列に結合するための N 個の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列の要素をタプルにまとめた配列を返します。タプル内のデータ型は入力配列の型と同じで、配列が渡された順序と同じ順に並びます [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
```
```response title=Response theme={null}
[('a', 5), ('b', 2), ('c', 1)]
```
## arrayZipUnaligned
導入バージョン: v20.1.0
複数の配列を 1 つの配列に結合します。長さの異なる配列同士でも結合できます。結果の配列には、ソース配列の対応する要素が、引数に列挙された順序でタプルとしてまとめられて格納されます。
**構文**
```sql theme={null}
arrayZipUnaligned(arr1, arr2, ..., arrN)
```
**引数**
* `arr1, arr2, ..., arrN` — 1つの配列に結合する N 個の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
ソース配列の要素をタプルとしてまとめた配列を返します。タプル内のデータ型は入力配列の型と同じで、配列を渡した順序もそのまま保持されます。[`Array(T)`](/ja/reference/data-types/array) または [`Tuple(T1, T2, ...)`](/ja/reference/data-types/tuple)
**例**
**使用例**
```sql title=Query theme={null}
SELECT arrayZipUnaligned(['a'], [1, 2, 3]);
```
```response title=Response theme={null}
[('a', 1),(NULL, 2),(NULL, 3)]
```
## countEqual
導入バージョン: v1.1.0
配列内で `x` に等しい要素の数を返します。`arrayCount(elem -> elem = x, arr)` と同等です。
`NULL` 要素は独立した値として扱われます。
**構文**
```sql theme={null}
countEqual(arr, x)
```
**引数**
* `arr` — 検索対象の Array。[`Array(T)`](/ja/reference/data-types/array)
* `x` — 配列内で個数を数える値。任意の型。
**戻り値**
配列内で `x` に等しい要素の数を返します。[`UInt64`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT countEqual([1, 2, NULL, NULL], NULL)
```
```response title=Response theme={null}
2
```
## empty
導入バージョン: v1.1.0
入力された配列が空かどうかを判定します。
配列に要素が1つも含まれていない場合、その配列は空と見なされます。
[`optimize_functions_to_subcolumns` 設定](/ja/reference/settings/session-settings#optimize_functions_to_subcolumns)を有効にすることで最適化できます。`optimize_functions_to_subcolumns = 1` の場合、この関数は配列カラム全体を読み取って処理する代わりに、[size0](/ja/reference/data-types/array#array-size) サブカラムのみを読み取ります。クエリ `SELECT empty(arr) FROM TABLE;` は `SELECT arr.size0 = 0 FROM TABLE;` に変換されます。
この関数は String や UUID に対しても使用できます。
**構文**
```sql theme={null}
empty(arr)
```
**引数**
* `arr` — 入力Array。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
空のArrayの場合は `1`、空でないArrayの場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT empty([]);
```
```response title=Response theme={null}
1
```
## emptyArrayDate
導入バージョン: v1.1.0
Date 型の空の配列を返します
**構文**
```sql theme={null}
emptyArrayDate()
```
**引数**
* なし。
**戻り値**
空のDate配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayDate
```
```response title=Response theme={null}
[]
```
## emptyArrayDateTime
導入バージョン: v1.1.0
空のDateTime配列を返します
**構文**
```sql theme={null}
emptyArrayDateTime()
```
**引数**
* なし。
**戻り値**
空の DateTime の配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayDateTime
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat32
導入バージョン: v1.1.0
空の Float32 型の配列を返します
**構文**
```sql theme={null}
emptyArrayFloat32()
```
**引数**
* なし。
**戻り値**
空の Float32 の配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayFloat32
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat64
導入バージョン: v1.1.0
空のFloat64 Arrayを返します
**構文**
```sql theme={null}
emptyArrayFloat64()
```
**引数**
* なし。
**戻り値**
空の Float64 配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayFloat64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt16
導入バージョン: v1.1.0
空の Int16 型の配列を返します
**構文**
```sql theme={null}
emptyArrayInt16()
```
**引数**
* なし。
**戻り値**
空の Int16 配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayInt32
導入バージョン: v1.1.0
空の Int32 Array を返します
**構文**
```sql theme={null}
emptyArrayInt32()
```
**引数**
* なし
**戻り値**
空の Int32 配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayInt64
導入バージョン: v1.1.0
空の Int64 Array を返します
**構文**
```sql theme={null}
emptyArrayInt64()
```
**引数**
* なし
**戻り値**
空の Int64 の配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt8
導入バージョン: v1.1.0
空の Int8 Array を返します
**構文**
```sql theme={null}
emptyArrayInt8()
```
**引数**
* なし。
**戻り値**
空のInt8配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayInt8
```
```response title=Response theme={null}
[]
```
## emptyArrayString
導入バージョン: v1.1.0
空のString配列を返します
**構文**
```sql theme={null}
emptyArrayString()
```
**引数**
* なし。
**戻り値**
空の String 配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayString
```
```response title=Response theme={null}
[]
```
## emptyArrayToSingle
導入バージョン: v1.1.0
空の配列を受け取り、デフォルト値に等しい1要素の配列を返します。
**構文**
```sql theme={null}
emptyArrayToSingle(arr)
```
**引数**
* `arr` — 空の配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
Array のデフォルト型の値を 1 つ持つ配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**基本例**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0] │ [''] │ ['1970-01-01 01:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘
```
## emptyArrayUInt16
導入バージョン: v1.1.0
空の UInt16 の配列を返します
**構文**
```sql theme={null}
emptyArrayUInt16()
```
**引数**
* なし。
**戻り値**
UInt16 の空の配列。 [`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayUInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt32
導入バージョン: v1.1.0
空の UInt32 Array を返します
**構文**
```sql theme={null}
emptyArrayUInt32()
```
**引数**
* なし。
**戻り値**
空の UInt32 の配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayUInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt64
導入バージョン: v1.1.0
空の UInt64 配列を返します
**構文**
```sql theme={null}
emptyArrayUInt64()
```
**引数**
* なし。
**戻り値**
空の UInt64 の配列です。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayUInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt8
導入バージョン: v1.1.0
空の UInt8 配列を返します
**構文**
```sql theme={null}
emptyArrayUInt8()
```
**引数**
* なし。
**戻り値**
空の UInt8 の配列。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayUInt8
```
```response title=Response theme={null}
[]
```
## 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))`) 。
**構文**
```sql theme={null}
has(haystack, needle)
```
**引数**
* `haystack` — ソース配列、Map、または JSON。[`Array`](/ja/reference/data-types/array) または [`Map`](/ja/reference/data-types/map) または [`JSON`](/ja/reference/data-types/newjson)
* `needle` — 検索する値 (配列内の要素、Map のキー、または JSON のパス文字列) 。
**戻り値**
`haystack` に指定した `needle` が含まれている場合は `1`、含まれていない場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**Array の基本的な使い方**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 2)
```
```response title=Response theme={null}
1
```
**Array が見つかりません**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 4)
```
```response title=Response theme={null}
0
```
**Map の基本的な使い方**
```sql title=Query theme={null}
SELECT has(map('a', 1, 'b', 2), 'b')
```
```response title=Response theme={null}
1
```
**JSON パス**
```sql title=Query theme={null}
SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')
```
```response title=Response theme={null}
1
```
## hasAll
導入バージョン: v1.1.0
一方の配列がもう一方の配列の部分集合であるかどうかを判定します。
* 空の配列は、任意の配列の部分集合です。
* `Null` は値として処理されます。
* どちらの配列でも、値の順序は関係ありません。
**構文**
```sql theme={null}
hasAll(set, subset)
```
**引数**
* `set` — 要素の集合を持つ、任意の型の Array。[`Array(T)`](/ja/reference/data-types/array)
* `subset` — `set` と共通のスーパータイプを持ち、`set` の部分集合かどうかを判定する対象の要素を含む、任意の型の Array。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
* `1` — `set` に `subset` のすべての要素が含まれる場合。
* `0` — それ以外の場合。
`set` と `subset` の要素が共通のスーパータイプを持たない場合は、`NO_COMMON_TYPE` 例外が発生します。
**例**
**空の配列**
```sql title=Query theme={null}
SELECT hasAll([], [])
```
```response title=Response theme={null}
1
```
**NULL 値を含む Array**
```sql title=Query theme={null}
SELECT hasAll([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**異なる型の値を含む Array**
```sql title=Query theme={null}
SELECT hasAll([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
1
```
**String 型の値を含む配列**
```sql title=Query theme={null}
SELECT hasAll(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**共通の型を持たない Array**
```sql title=Query theme={null}
SELECT hasAll([1], ['a'])
```
```response title=Response theme={null}
NO_COMMON_TYPE 例外が発生します
```
**ArrayのArray**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])
```
```response title=Response theme={null}
0
```
## hasAny
導入バージョン: v1.1.0
2 つの配列に共通する要素があるかどうかを判定します。
* `Null` は値として処理されます。
* どちらの配列でも、値の順序は問いません。
**構文**
```sql theme={null}
hasAny(arr_x, arr_y)
```
**引数**
* `arr_x` — 要素の集合を持つ任意の型の Array。[`Array(T)`](/ja/reference/data-types/array)
* `arr_y` — Array `arr_x` と共通スーパータイプを持つ任意の型の Array。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
* `1` — `arr_x` と `arr_y` に共通する要素が少なくとも 1 つある場合。
* `0` — それ以外の場合。
2 つの Array の要素同士に共通スーパータイプを持たないものがある場合は、`NO_COMMON_TYPE` 例外が発生します。
**例**
**一方の Array が空の場合**
```sql title=Query theme={null}
SELECT hasAny([1], [])
```
```response title=Response theme={null}
0
```
**NULL 値を含む Array**
```sql title=Query theme={null}
SELECT hasAny([Null], [Null, 1])
```
```response title=Response theme={null}
1
```
**異なる型の値を含む配列**
```sql title=Query theme={null}
SELECT hasAny([-128, 1., 512], [1])
```
```response title=Response theme={null}
1
```
**共通の型がないArray**
```sql title=Query theme={null}
SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])
```
```response title=Response theme={null}
`NO_COMMON_TYPE` 例外が発生します
```
**ArrayのArray**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])
```
```response title=Response theme={null}
1
```
## 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` 例外を発生させます。
**構文**
```sql theme={null}
hasSubstr(arr1, arr2)
```
**引数**
* `arr1` — 要素の集合からなる任意の型の Array。[`Array(T)`](/ja/reference/data-types/array)
* `arr2` — 要素の集合からなる任意の型の Array。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
配列 `arr1` が配列 `arr2` を含む場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**両方の配列が空の場合**
```sql title=Query theme={null}
SELECT hasSubstr([], [])
```
```response title=Response theme={null}
1
```
**NULL 値を含む Array**
```sql title=Query theme={null}
SELECT hasSubstr([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**異なる型の値を含むArray**
```sql title=Query theme={null}
SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
0
```
**文字列を含む配列**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**順序付けが有効なArray**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])
```
```response title=Response theme={null}
1
```
**順序が不正な Array**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])
```
```response title=Response theme={null}
0
```
**Arrayの配列**
```sql title=Query theme={null}
SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])
```
```response title=Response theme={null}
1
```
**共通の型を持たない配列**
```sql title=Query theme={null}
SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])
```
```response title=Response theme={null}
`NO_COMMON_TYPE` 例外が発生します
```
## indexOf
導入バージョン: v1.1.0
配列内に値 'x' を持つ最初の要素がある場合、その位置 (1 から始まる) を返します。
配列に検索対象の値が含まれていない場合、関数は `0` を返します。
`NULL` に設定された要素も通常の値として扱われます。
**構文**
```sql theme={null}
indexOf(arr, x)
```
**引数**
* `arr` — `x` を検索する対象の配列。[`Array(T)`](/ja/reference/data-types/array)
* `x` — `arr` 内で最初に一致する要素の値。この値に対応する索引を返します。[`UInt64`](/ja/reference/data-types/int-uint)
**戻り値**
`arr` に `x` が存在する場合は、最初の `x` の索引 (1 から始まる番号) を返します。存在しない場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint)
**例**
**基本的な例**
```sql title=Query theme={null}
SELECT indexOf([5, 4, 1, 3], 3)
```
```response title=Response theme={null}
4
```
**NULL を含む Array**
```sql title=Query theme={null}
SELECT indexOf([1, 3, NULL, NULL], NULL)
```
```response title=Response theme={null}
3
```
## indexOfAssumeSorted
導入バージョン: v24.12.0
配列内に値 'x' を持つ要素がある場合、その最初の要素の位置 (`1` から始まる) を返します。
配列に検索対象の値が含まれていない場合、この関数は `0` を返します。
`indexOf` 関数とは異なり、この関数は配列が昇順に
ソートされていることを前提としています。配列がソートされていない場合、結果は未定義です。
**構文**
```sql theme={null}
indexOfAssumeSorted(arr, x)
```
**引数**
* `arr` — 検索対象のソート済み配列。[`Array(T)`](/ja/reference/data-types/array)
* `x` — ソート済みの `arr` 内で最初に一致した要素のうち、その索引を返す対象となる値。[`UInt64`](/ja/reference/data-types/int-uint)
**戻り値**
`arr` 内に `x` が存在する場合は、最初の `x` の索引 (1 から始まる) を返します。存在しない場合は、`0` を返します。[`UInt64`](/ja/reference/data-types/int-uint)
**例**
**基本例**
```sql title=Query theme={null}
SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)
```
```response title=Response theme={null}
5
```
## kql\_array\_sort\_asc
導入バージョン: v23.10.0
1 つ以上の配列を昇順にソートします。最初の配列がソートされ、後続の配列はそのソート順に合わせて並べ替えられます。NULL 値は末尾に配置されます。これは KQL (Kusto Query Language) 互換関数です。
**構文**
```sql theme={null}
kql_array_sort_asc(array1[, array2, ..., nulls_last])
```
**引数**
* `array1` — ソート対象の配列です。[`Array(T)`](/ja/reference/data-types/array)
* `array2` — 任意。`array1` のソート順に合わせて並べ替える追加の配列です。[`Array(T)`](/ja/reference/data-types/array)
* `nulls_last` — 任意。NULL を最後に配置するかどうかを示すブール値です。デフォルトは true です。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
昇順にソートされた配列のタプルを返します。[`Tuple(Array, ...)`](/ja/reference/data-types/tuple)
**例**
**基本的な使い方**
```sql title=Query theme={null}
SELECT kql_array_sort_asc([3, 1, 2])
```
```response title=Response theme={null}
([1, 2, 3])
```
## kql\_array\_sort\_desc
導入バージョン: v23.10.0
1 つ以上の配列を降順にソートします。最初の配列がソートされ、以降の配列はその並び順に合わせて並べ替えられます。NULL 値は末尾に配置されます。これは KQL (Kusto Query Language) との互換性のための関数です。
**構文**
```sql theme={null}
kql_array_sort_desc(array1[, array2, ..., nulls_last])
```
**引数**
* `array1` — ソート対象の配列です。[`Array(T)`](/ja/reference/data-types/array)
* `array2` — `array1` のソート順に合わせて並べ替える、任意の追加配列です。[`Array(T)`](/ja/reference/data-types/array)
* `nulls_last` — null を末尾に配置するかどうかを示す任意のブール値です。デフォルトは true です。[`UInt8`](/ja/reference/data-types/int-uint)
**戻り値**
降順にソートされた配列のタプルを返します。[`Tuple(Array, ...)`](/ja/reference/data-types/tuple)
**例**
**基本的な使い方**
```sql title=Query theme={null}
SELECT kql_array_sort_desc([3, 1, 2])
```
```response title=Response theme={null}
([3, 2, 1])
```
## length
導入バージョン: v1.1.0
文字列または配列の長さを計算します。
* String または FixedString 引数の場合: 文字列のバイト数を計算します。
* Array 引数の場合: 配列の要素数を計算します。
* FixedString 引数に適用した場合、この関数は定数式になります。
文字列のバイト数は、Unicode の "code points" の数とも、
Unicode の "grapheme clusters" の数
(通常「文字」と呼ばれるもの) とも、表示上の文字幅とも一致しない点に注意してください。
文字列に ASCII の NULL バイトを含めることは可能で、それらもカウントされます。
**構文**
```sql theme={null}
length(x)
```
**別名**: `OCTET_LENGTH`
**引数**
* `x` — バイト数 (String/FixedString の場合) または要素数 (Array の場合) を計算する値。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`Array(T)`](/ja/reference/data-types/array)
**戻り値**
String/FixedString `x` のバイト数、または配列 `x` の要素数を返します。[`UInt64`](/ja/reference/data-types/int-uint)
**例**
**Stringの例**
```sql title=Query theme={null}
SELECT length('Hello, world!')
```
```response title=Response theme={null}
13
```
**Arrayの例**
```sql title=Query theme={null}
SELECT length(['Hello', 'world'])
```
```response title=Response theme={null}
2
```
**constexprの例**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │ 0 │ 1 │
│ hello1 │ 0 │ 1 │
│ hello2 │ 0 │ 1 │
└────────┴────────────────────────┴──────────────────────────────┘
```
**Unicode の例**
```sql title=Query theme={null}
SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)
```
```response title=Response theme={null}
┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │ 8 │ 4 │ ёлка │ 10 │ 5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘
```
**ascii\_vs\_utf8 の例**
```sql title=Query theme={null}
SELECT 'ábc' AS str, length(str), lengthUTF8(str)
```
```response title=Response theme={null}
┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │ 4 │ 3 │
└─────┴──────────────┴─────────────────┘
```
## notEmpty
導入バージョン: v1.1.0
入力された Array が空でないかどうかを確認します。
Array は、少なくとも 1 つの要素を含んでいれば空ではないと見なされます。
[`optimize_functions_to_subcolumns`](/ja/reference/settings/session-settings#optimize_functions_to_subcolumns) 設定を有効にすると、この関数を最適化できます。`optimize_functions_to_subcolumns = 1` の場合、この関数は Array 全体のカラムを読み取って処理する代わりに、[size0](/ja/reference/data-types/array#array-size) サブカラムだけを読み取ります。クエリ `SELECT notEmpty(arr) FROM table` は `SELECT arr.size0 != 0 FROM TABLE` に変換されます。
この関数は String や UUID に対しても使用できます。
**構文**
```sql theme={null}
notEmpty(arr)
```
**引数**
* `arr` — 入力配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
空でない配列の場合は `1`、空の配列の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT notEmpty([1,2]);
```
```response title=Response theme={null}
1
```
## 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`](/ja/reference/settings/session-settings#function_range_max_elements_in_block) で指定された要素数を超える合計長の配列を返す場合、例外が発生します。
* いずれかの引数の型が Nullable(nothing) の場合は `NULL` を返します。いずれかの引数の値が `NULL` (Nullable(T) 型) の場合は、例外が発生します。
**構文**
```sql theme={null}
range([start, ] end [, step])
```
**引数**
* `start` — 任意。配列の先頭要素です。`step` を使用する場合は必須です。デフォルト値: `0`。 - `end` — 必須。配列がこの値の直前まで生成される数値です。 - `step` — 任意。配列の各要素間の増分を指定します。デフォルト値: `1`。
**戻り値**
`start` から `end - 1` までを `step` 刻みで並べた数値の Array。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);
```
```response title=Response theme={null}
┌─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
単一の値を含む配列を作成します。
**構文**
```sql theme={null}
replicate(x, arr)
```
**引数**
* `x` — 結果の配列を値 `x` で埋めるための値。[`Any`](/ja/reference/data-types)
* `arr` — 配列。[`Array(T)`](/ja/reference/data-types/array)
**戻り値**
`arr` と同じ長さで、各要素が値 `x` の配列を返します。[`Array(T)`](/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT replicate(1, ['a', 'b', 'c']);
```
```response title=Response theme={null}
┌─replicate(1, ['a', 'b', 'c'])───┐
│ [1, 1, 1] │
└─────────────────────────────────┘
```
## reverse
導入バージョン: v1.1.0
入力 `Array` の要素の並び、または入力文字列内の文字の並びを逆順にします。
**構文**
```sql theme={null}
reverse(arr | str)
```
**引数**
* `arr | str` — ソース配列または文字列。[`Array(T)`](/ja/reference/data-types/array) または [`String`](/ja/reference/data-types/string)
**戻り値**
要素または文字の並び順を逆にした配列または文字列を返します。
**例**
**配列を逆順にする**
```sql title=Query theme={null}
SELECT reverse([1, 2, 3, 4]);
```
```response title=Response theme={null}
[4, 3, 2, 1]
```
**文字列の反転**
```sql title=Query theme={null}
SELECT reverse('abcd');
```
```response title=Response theme={null}
'dcba'
```
## 距離関数
サポートされているすべての関数については、[距離関数のドキュメント](/ja/reference/functions/regular-functions/distance-functions)を参照してください。