> ## Documentation Index
> Fetch the complete documentation index at: https://clickhouse.com/docs/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)`](/docs/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*)`](/docs/ja/reference/data-types/array) または [`Array(Float*)`](/docs/ja/reference/data-types/array)
* `labels` — サンプルのラベル。通常、正例は 1、負例は 0 です。[`Array((U)Int*)`](/docs/ja/reference/data-types/array) または [`Array(Enum)`](/docs/ja/reference/data-types/array)
* `partial_offsets` —
* 任意。AUC 全体ではなく PR 曲線下面積の一部 (PR 空間における垂直帯に相当) を計算するための、3 つの非負整数からなる [`Array(T)`](/docs/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`](/docs/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`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理するソース配列です。[`Array(T)`](/docs/ja/reference/data-types/array)
* `cond1_arr, ...` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
すべての要素に対してラムダ関数が true を返す場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/docs/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)`](/docs/ja/reference/data-types/array)
* `max_lag` — 任意。計算するラグの最大数です。0 以上の整数である必要があります。[`Integer`](/docs/ja/reference/data-types/int-uint)
**戻り値**
Float64 の Array を返します。分散が 0 の場合は NaN を返します。[`Array(Float64)`](/docs/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`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
ソース配列の要素の平均値を返します。ラムダ関数が指定されている場合は、その結果の要素の平均値を返します。[`Float64`](/docs/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
```
## arrayBottomK
導入バージョン: v26.6.0
入力 Array 内の最小の K 個の要素を、昇順にソートした配列として返します。
ラムダ関数 `f` を指定した場合、要素同士は各要素に `f` を適用した結果に基づいて比較されます。
`f` が複数の引数を受け取る場合は、追加の配列が `arrayBottomK` に渡され、それらの要素が
`f` の引数に対応します。
`NULL` 値はスキップされ、結果には含まれません。結果のサイズは最大 `K` です。
また、入力配列に含まれる非 NULL の要素数が `K` 未満の場合は、これより小さくなることがあります。
結果の要素型は、入力要素型に対応する非 Nullable 型です。
`arrayBottomK` は[高階関数](/docs/ja/reference/functions/regular-functions/overview#higher-order-functions)です。
関連項目:
* 代わりに最大の K 個の要素を返す `arrayTopK`。
* 同じ K 個の要素を位置 `[1..K]` に返しますが、
残りの要素も順序未指定のまま保持し、null をスキップしない `arrayPartialSort`。
**構文**
```sql theme={null}
arrayBottomK([f,] K, arr [, arr1, ... ,arrN])
```
**引数**
* `f(arr[, arr1, ... ,arrN])` — 任意。各要素のソートキーを計算するためのラムダ関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `K` — 返される最小要素数。[`(U)Int8/16/32/64`](/docs/ja/reference/data-types/int-uint)
* `arr` — 配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `arr1, ... ,arrN` — `f` が複数の引数を受け取る場合に使う、追加の `N` 個の配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
`arr` のうち値が最も小さい要素 (またはラムダ関数の結果が最も小さい要素) を最大 `K` 個、昇順にソートして返します。
NULL 値はスキップされます。入力の型が `Nullable(T)` の場合でも、返される配列の要素型は `T` です。
**例**
**simple\_int**
```sql title=Query theme={null}
SELECT arrayBottomK(3, [1, 5, 2, 7, 3])
```
```response title=Response theme={null}
[1,2,3]
```
**skip\_nulls**
```sql title=Query theme={null}
SELECT arrayBottomK(3, [1, NULL, 5, 2, NULL, 7])
```
```response title=Response theme={null}
[1,2,5]
```
**fewer\_than\_k**
```sql title=Query theme={null}
SELECT arrayBottomK(5, [1, NULL, 2])
```
```response title=Response theme={null}
[1,2]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayBottomK((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9,5]
```
**lambda\_multi**
```sql title=Query theme={null}
SELECT arrayBottomK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])
```
```response title=Response theme={null}
['b','c']
```
## arrayCompact
導入バージョン: v20.1.0
配列から、`null` 値を含む連続した重複要素を削除します。結果の配列における値の順序は、ソース配列での順序によって決まります。
**構文**
```sql theme={null}
arrayCompact(arr)
```
**引数**
* `arr` — 重複を削除する対象の配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
重複した値を含まない配列を返します [`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
指定された配列引数を連結した 1 つの配列を返します。[`Array(T)`](/docs/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` は[高階関数](/docs/ja/reference/functions/regular-functions/overview#higher-order-functions)です。
**構文**
```sql theme={null}
arrayCount([func, ] arr1, ...)
```
**引数**
* `func` — オプション。各配列の各要素に適用する関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1, ..., arrN` — N 個の配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
`func` が true を返す要素の数を返します。`func` を指定しない場合は、配列内の 0 以外の要素数を返します。[`UInt32`](/docs/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` — 任意。各位置の配列要素に適用するラムダ関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — 数値のソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[arr2, ..., arrN]` — 任意。同じサイズの追加の配列です。指定した場合は、ラムダ関数の引数として渡されます。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
ソース配列の要素の累積和からなる配列を返します。結果の型は、入力配列の数値型と一致します。[`Array(T)`](/docs/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` — 任意。各位置の配列要素に適用するラムダ関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — 数値からなるソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[arr2, ..., arrN]` — 任意。同じサイズの追加配列です。指定した場合は、ラムダ関数に引数として渡されます。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
ソース配列の要素の累積和からなる配列を返します。累積和が途中で負になった場合は 0 に置き換えられます。結果の型は入力配列の数値型と一致します。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
隣接する配列要素同士の差分を格納した配列を返します。 [`UInt*`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
重複のない要素を含む Array を返します [`Array(T)`](/docs/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* | BFloat16 | Decimal)`](/docs/ja/reference/data-types/array) または [`Tuple((U)Int* | Float* | Decimal)`](/docs/ja/reference/data-types/tuple)
* `v2` — 第2ベクトル。[`Array((U)Int* | Float* | BFloat16 | Decimal)`](/docs/ja/reference/data-types/array) または [`Tuple((U)Int* | Float* | Decimal)`](/docs/ja/reference/data-types/tuple)
**戻り値**
2つのベクトルの内積。
戻り値の型は引数の型によって決まります。Array または Tuple に異なる要素型が混在している場合、結果の型は共通の上位型になります。
2 つの `BFloat16` 配列は `Float32` で累積され、`Float32` を返します (2 つの `Float32` 配列と同じ規則です) 。
[`(U)Int*`](/docs/ja/reference/data-types/int-uint) または [`Float*`](/docs/ja/reference/data-types/float) または [`Decimal`](/docs/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)`](/docs/ja/reference/data-types/array). - `n` — 取得する要素の位置。[`(U)Int*`](/docs/ja/reference/data-types/int-uint).
**戻り値**
指定された配列引数を結合した 1 つの配列を返します。[`Array(T)`](/docs/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`](/docs/ja/reference/data-types/array)
**戻り値**
指定された配列引数を結合した 1 つの配列を返します。[`Array(T)`](/docs/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`](/docs/ja/reference/statements/select/array-join) 句とともに使用されます。これにより、`ARRAY JOIN` の適用後に、各配列につき
1 回だけカウントできるようになります。
この関数は高階関数でも使用できます。たとえば、条件に一致する要素の配列内インデックスを取得するために使用できます。
**構文**
```sql theme={null}
arrayEnumerate(arr)
```
**引数**
* `arr` — 列挙対象の配列。[`Array`](/docs/ja/reference/data-types/array)
**戻り値**
配列 `[1, 2, 3, ..., length (arr)]` を返します。[`Array(UInt32)`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
`arr` と同じサイズの配列を返します。各要素がソース配列内で最初に現れる位置を示します。[`Array(T)`](/docs/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*`](/docs/ja/reference/data-types/int-uint)
* `arr` — 列挙対象の N 次元配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `max_array_depth` — 有効な最大深さです。`arr` の深さ以下でなければなりません。[`UInt*`](/docs/ja/reference/data-types/int-uint)
**戻り値**
各要素がソース配列内で最初に出現する位置を示す配列を返します。[`Array`](/docs/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)`](/docs/ja/reference/data-types/array)
* `arr2, ...` — 任意。同じサイズの追加の配列で、タプルの一意性を判定するために使用します。[`Array(UInt32)`](/docs/ja/reference/data-types/array)
**戻り値**
各要素について、同じ値またはタプルを持つ要素の中での位置を表す配列を返します。[`Array(T)`](/docs/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*`](/docs/ja/reference/data-types/int-uint)
* `arr` — 列挙対象の N 次元配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `max_array_depth` — 有効な最大深度。`arr` の深度以下の正の整数。[`UInt*`](/docs/ja/reference/data-types/int-uint)
**戻り値**
`arr` と同じサイズの N 次元配列を返します。各要素には、同じ値を持つ他の要素に対するその要素の位置が示されます。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `except` — 結果から除外する要素を含む配列です。 [`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
`except` に含まれない `source` の要素を含む、入力配列と同じ型の配列を返します。 [`Array(T)`](/docs/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`) の要素に対して動作するラムダ関数です。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理するソース配列です。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
少なくとも 1 つの要素に対してラムダ関数が true を返す場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/docs/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])`。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
配列 [`Array(T)`](/docs/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`) の各要素に対して処理を行うラムダ関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
ソース配列の部分集合 [`Array(T)`](/docs/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`) の要素に対して動作するラムダ関数。[ラムダ関数](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source_arr` — 処理するソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)。 - `[, cond1_arr, ... , condN_arr]` — 省略可能。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/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](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source_arr` — 処理対象のソース配列です。[`Array(T)`](/docs/ja/reference/data-types/array)。 - `[, cond1_arr, ... , condN_arr]` — 省略可能。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/docs/ja/reference/data-types/array)。
**戻り値**
`func` が true となるソース配列の最初の要素の索引を返します。該当する要素がない場合は `0` を返します [`UInt32`](/docs/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`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理するソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/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))`](/docs/ja/reference/data-types/array)
**戻り値**
多次元配列をフラット化した [`Array(T)`](/docs/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` が繰り返し再利用されます。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1 [, arr2, arr3, ... arrN]` — 演算の対象となる N 個の配列。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array).
**戻り値**
N 個すべての配列に共通して含まれる重複のない要素からなる配列を返します [`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `arr_y` — 2 つ目の配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
`arr_x` と `arr_y` のジャカード係数を返します。[`Float64`](/docs/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` 関数は、Array を含む1つの行を受け取り、それを展開して、Array の各要素ごとに1行ずつ、複数の行を生成します。
これは、同じ行の中で入力値を出力値に対応付ける ClickHouse の通常の関数や、
複数の行のグループを1つの要約行に「圧縮」または「集約」する集約関数
(`GROUP BY` とともに使用した場合は、要約行内の単一の値) とは対照的です。
この関数が適用されたカラムを除き、他のカラムの値はそのままコピーされます。
適用されたカラムの値は、対応する Array の要素の値に置き換えられます。
この関数は非決定論的です。同じ引数に対して異なる結果を返すことがあります。
**構文**
```sql theme={null}
arrayJoin(arr)
```
**別名**: `unnest`
**引数**
* `arr` — 展開する Array。[`Array(T)`](/docs/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}
-- The arrayJoin function affects all sections of the query, including the WHERE section. Notice the result 2, even though the subquery returned 1 row.
SELECT sum(1) AS impressions
FROM
(
SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];
```
```response title=Response theme={null}
┌─impressions─┐
│ 2 │
└─────────────┘
```
**複数の arrayJoin 関数を使用する**
```sql title=Query theme={null}
-- A query can use multiple arrayJoin functions. In this case, the transformation is performed multiple times and the rows are multiplied.
SELECT
sum(1) AS impressions,
arrayJoin(cities) AS city,
arrayJoin(browsers) AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
ORDER BY
city,
browser
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 2 │ Berlin │ Chrome │
│ 1 │ Berlin │ Firefox │
│ 2 │ Bobruisk │ Chrome │
│ 1 │ Bobruisk │ Firefox │
│ 2 │ Istanbul │ Chrome │
│ 1 │ Istanbul │ Firefox │
└─────────────┴──────────┴─────────┘
```
**最適化によって予期しない結果が生じる場合**
```sql title=Query theme={null}
-- Using multiple arrayJoin with the same expression may not produce the expected result due to optimizations.
-- For these cases, consider modifying the repeated array expression with extra operations that do not affect join result.
-- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))
SELECT
arrayJoin(dice) as first_throw,
/* arrayJoin(dice) as second_throw */ -- is technically correct, but will annihilate result set
arrayJoin(arrayConcat(dice, [])) as second_throw -- intentionally changed expression to force re-evaluation
FROM (
SELECT [1, 2, 3, 4, 5, 6] as dice
);
```
```response 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}
-- Note the ARRAY JOIN syntax in the `SELECT` query below, which provides broader possibilities.
-- ARRAY JOIN allows you to convert multiple arrays with the same number of elements at a time.
SELECT
sum(1) AS impressions,
city,
browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
cities AS city,
browsers AS browser
GROUP BY
2,
3
ORDER BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
│ 1 │ Istanbul │ Firefox │
└─────────────┴──────────┴─────────┘
```
**Tupleの使用**
```sql title=Query theme={null}
-- You can also use Tuple
SELECT
sum(1) AS impressions,
(arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
t.2 AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
ORDER BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
│ 1 │ Istanbul │ Firefox │
└─────────────┴──────────┴─────────┘
```
## 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](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source` — 処理対象のソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)。 - `[, cond1, ... , condN]` — 省略可。ラムダ関数に追加の引数を渡すための N 個の条件配列です。[`Array(T)`](/docs/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`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 省略可能。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
`func` が true となるソース配列の最後の要素の索引を返します。該当する要素がない場合は `0` を返します。 [`UInt32`](/docs/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`) の要素に対して適用されるラムダ関数です。[ラムダ関数](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source_arr` — 処理対象のソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)。 - `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)。 - `to` — 2 つ目の配列。[`Array(T)`](/docs/ja/reference/data-types/array)。
**戻り値**
1 つ目と 2 つ目の配列の間のレーベンシュタイン距離。[`Float64`](/docs/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)`](/docs/ja/reference/data-types/array)。 - `to` — 第2の配列。[`Array(T)`](/docs/ja/reference/data-types/array)。 - `from_weights` — 第1の配列の重み。[`Array((U)Int*|Float*)`](/docs/ja/reference/data-types/array)
* `to_weights` — 第2の配列の重み。[`Array((U)Int*|Float*)`](/docs/ja/reference/data-types/array)
**戻り値**
各要素にカスタム重みを設定した、第1および第2の配列間のレーベンシュタイン距離。[`Float64`](/docs/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`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — 処理対象の配列を N 個指定します。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
ラムダ関数の結果からなる配列を返します。[`Array(T)`](/docs/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`) の要素に対して処理を行うラムダ関数です。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列です。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/docs/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`) の要素に対して処理を行うラムダ関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `cond1_arr, ...` — オプション。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `label` — 正解値。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
予測値のジニ係数、正規化値のジニ係数、および正規化ジニ係数 (= 前者2つのジニ係数の比) を含むタプル。[`Tuple(Float64, Float64, Float64)`](/docs/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,] limit, arr [, arr1, ... ,arrN])
```
**引数**
* `f(arr[, arr1, ... ,arrN])` — 配列 `x` の要素に適用するラムダ関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `limit` — どこまでソートするかを示す索引値。[`(U)Int*`](/docs/ja/reference/data-types/int-uint)
* `arr` — ソート対象の配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `arr1, ... ,arrN` — `f` が複数の引数を受け取る場合に指定する、追加の N 個の配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
元の配列と同じサイズの配列を返します。この配列では、範囲 `[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)`](/docs/ja/reference/data-types/array)
* `seed` — 任意。乱数生成に使用するシード値です。指定しない場合はランダムな値が使用されます。[`(U)Int*`](/docs/ja/reference/data-types/int-uint)
* `limit` — 任意。要素の入れ替え回数を `[1..N]` の範囲に制限するための数値です。[`(U)Int*`](/docs/ja/reference/data-types/int-uint)
**戻り値**
要素の一部がシャッフルされた Array。[`Array(T)`](/docs/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,] limit, arr [, arr1, ... ,arrN])
```
**引数**
* `f(arr[, arr1, ... ,arrN])` — 配列 `x` の要素に適用するラムダ関数です。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `limit` — ソートを行う範囲の終端を表す索引値です。[`(U)Int*`](/docs/ja/reference/data-types/int-uint)
* `arr` — ソートする Array です。[`Array(T)`](/docs/ja/reference/data-types/array)
* `arr1, ... ,arrN` — `f` が複数の引数を受け取る場合に使用する、追加の N 個の配列です。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
元の配列と同じサイズの配列を返します。この配列では、範囲 `[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)`](/docs/ja/reference/data-types/array)
**戻り値**
`arr` と同じ配列から末尾の要素を取り除いた配列を返します。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
`arr` と同じですが、`arr` の先頭要素を除いた配列を返します [`Array(T)`](/docs/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`) の要素に対して処理を行うラムダ関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
ソース配列の要素の積、または指定されている場合はラムダ関数の結果要素の積を返します。[`Float64`](/docs/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)`](/docs/ja/reference/data-types/array)
* `x` —
* 配列の末尾に追加する単一の値です。[`Array(T)`](/docs/ja/reference/data-types/array)。
- 数値の配列に追加できるのは数値のみで、文字列の配列に追加できるのは文字列のみです。
- 数値を追加する場合、ClickHouse は配列のデータ型に合わせて `x` の型を自動的に設定します。
- `NULL` を指定できます。この関数は配列に `NULL` 要素を追加し、配列要素の型は `Nullable` に変換されます。
ClickHouse のデータ型について詳しくは、[Data types](/docs/ja/reference/data-types/index) を参照してください。
**戻り値**
`arr` と同じ内容で、配列の末尾に追加の値 `x` が加わった配列を返します。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)。 - `x` —
* 配列の先頭に追加する単一の値です。[`Array(T)`](/docs/ja/reference/data-types/array)。
- 数値の配列には数値のみ、文字列の配列には文字列のみを追加できます。
- 数値を追加する場合、ClickHouse は配列のデータ型に合わせて `x` の型を自動的に設定します。
- `NULL` も指定できます。この関数は配列に `NULL` 要素を追加し、配列要素の型は `Nullable` に変換されます。
ClickHouse のデータ型の詳細については、[Data types](/docs/ja/reference/data-types/index) を参照してください。
**戻り値**
`arr` と同一ですが、配列の先頭に追加の値 `x` が含まれる配列を返します [`Array(T)`](/docs/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*)`](/docs/ja/reference/data-types/array) または [`Array(Float*)`](/docs/ja/reference/data-types/array)
* `labels` — サンプルのラベル。通常、正例には 1、負例には 0 を使用します。[`Array((U)Int*)`](/docs/ja/reference/data-types/array) または [`Enum`](/docs/ja/reference/data-types/enum)
* `scale` — 任意。正規化された面積を返すかどうかを指定します。false の場合は、代わりに TP (真陽性) x FP (偽陽性) 曲線の下の面積を返します。デフォルト値: true。[`Bool`](/docs/ja/reference/data-types/boolean)
* `partial_offsets` —
* AUC 全体ではなく ROC 曲線の部分面積 (ROC 空間の縦方向の帯に相当) を計算するための、4 つの非負整数からなる配列です。このオプションは、ROC AUC の分散計算に役立ちます。配列には次の要素を含める必要があります: \[`higher_partitions_tp`, `higher_partitions_fp`, `total_positives`, `total_negatives`]。[Array](/docs/ja/reference/data-types/array) の非負の [Integers](/docs/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`](/docs/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)`](/docs/ja/reference/data-types/array)
* `samples` — ランダムサンプルに含める要素数です。[`(U)Int*`](/docs/ja/reference/data-types/int-uint)
**戻り値**
入力配列からランダムに抽出した要素のサンプルを含む配列 [`Array(T)`](/docs/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`](/docs/ja/reference/data-types/string)
* `arr1[, arr2, ... , arrN]` — `agg_f` の引数に対応する N 個の配列。[`Array(T)`](/docs/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`](/docs/ja/reference/data-types/string)
* `ranges` — 集約する範囲。集約を開始する索引 `i` と、集約対象の範囲 `r` を含む `(i, r)` 形式の Tuple の配列。[`Array(T)`](/docs/ja/reference/data-types/array) または [`Tuple(T)`](/docs/ja/reference/data-types/tuple)
* `arr1[, arr2, ... ,arrN]` — aggregate function に渡す N 個の配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
指定した範囲に対する aggregate function の結果を含む配列を返します。[`Array(T)`](/docs/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)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `size` —
-Array の新しい長さ。
`size` が Array の元のサイズより小さい場合、Array は右側から切り詰められます。
`size` が Array の初期サイズより大きい場合、Array は右側に `extender` の値、または Array 要素のデータ型のデフォルト値で拡張されます。
* `extender` — Array の拡張に使用する値。`NULL` を指定できます。
**戻り値**
長さが `size` の Array。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
元の配列と同じサイズで、要素が逆順に並んだ配列を返します。[`Array(T)`](/docs/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`) の要素に対して動作するラムダ関数です。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列です。[`Array(T)`](/docs/ja/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 任意です。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
ソース配列の各要素がラムダ関数の結果に置き換えられた配列を返します。[`Array(T)`](/docs/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` は[高階関数](/docs/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)`](/docs/ja/reference/data-types/array) - `arr1, ..., arrN` — 任意。`f` が複数の引数を受け取る場合に指定する、追加の N 個の配列。
**戻り値**
ラムダ関数が指定されていない場合は、配列 `x` を降順にソートして返します。指定されている場合は、
指定されたラムダ関数のロジックに従って配列をソートし、その後で反転した配列を返します。 [`Array(T)`](/docs/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`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列です。[`Lambda function`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
配列の配列を返します。[`Array(Array(T))`](/docs/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)`](/docs/ja/reference/data-types/array)。 - `n` — 回転させる要素数。[`(U)Int8/16/32/64`](/docs/ja/reference/data-types/int-uint)。
**戻り値**
指定した要素数だけ左に回転された配列 [`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)。 - `n` — ローテーションする要素の数。[`(U)Int8/16/32/64`](/docs/ja/reference/data-types/int-uint)。
**戻り値**
指定した数だけ右にローテーションされた配列 [`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)。 - `n` — シフトする要素数。[`(U)Int8/16/32/64`](/docs/ja/reference/data-types/int-uint)。 - `default` — 任意。新たに追加される要素のデフォルト値。
**戻り値**
指定した数の要素だけ左にシフトされた配列 [`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `n` — シフトする要素の数です。[`(U)Int8/16/32/64`](/docs/ja/reference/data-types/int-uint)
* `default` — 省略可。新しく作成される要素のデフォルト値です。
**戻り値**
指定した要素数だけ右にシフトされた配列です。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `l` — 各 shingle の長さ。[`(U)Int*`](/docs/ja/reference/data-types/int-uint)
**戻り値**
生成された shingle の配列 [`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `seed (optional)` — 省略可能です。乱数生成に使用するシード値です。指定しない場合は、ランダムな値が使用されます。[`(U)Int*`](/docs/ja/reference/data-types/int-uint)
**戻り値**
要素をシャッフルした Array [`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `to` — 2つ目の配列 [`Array(T)`](/docs/ja/reference/data-types/array)
* `from_weights` — 1つ目の配列の重み。 [`Array((U)Int*|Float*)`](/docs/ja/reference/data-types/array)
* `to_weights` — 2つ目の配列の重み。 [`Array((U)Int*|Float*)`](/docs/ja/reference/data-types/array)
**戻り値**
重み付きレーベンシュタイン距離に基づく、2つの配列間の `0` から `1` の類似度を返します [`Float64`](/docs/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)`](/docs/ja/reference/data-types/array)
* `offset` — 配列の端からの位置。正の値は左側からのオフセット、負の値は右側からのインデントを示します。配列要素の番号は `1` から始まります。[`(U)Int*`](/docs/ja/reference/data-types/int-uint)
* `length` — 必要なスライスの長さ。負の値を指定すると、関数は開区間のスライス `[offset, array_length - length]` を返します。値を省略すると、関数はスライス `[offset, the_end_of_array]` を返します。[`(U)Int*`](/docs/ja/reference/data-types/int-uint)
**戻り値**
指定した `offset` から `length` 個の要素を含む配列のスライスを返します。[`Array(T)`](/docs/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` は[高階関数](/docs/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)`](/docs/ja/reference/data-types/array) - `arr1, ..., arrN` — 任意。`f` が複数の引数を受け取る場合に指定する、追加の N 個の配列。
**戻り値**
ラムダ関数が指定されていない場合は、配列 `arr` を昇順にソートして返します。
指定されている場合は、指定されたラムダ関数のロジックに従ってソートされた配列を返します。 [`Array(T)`](/docs/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`) の要素に対して適用されるラムダ関数です。[ラムダ関数](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)。 - `source_arr` — 分割対象のソース配列 [`Array(T)`](/docs/ja/reference/data-types/array)。 - `[, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列です。 [`Array(T)`](/docs/ja/reference/data-types/array)。
**戻り値**
配列の配列を返します [`Array(Array(T))`](/docs/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`) の要素に対して処理を行うラムダ関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 処理対象のソース配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `, cond1_arr, ... , condN_arr]` — 任意。ラムダ関数に追加の引数を渡す N 個の条件配列。[`Array(T)`](/docs/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
複数のArrayを受け取り、すべてのソースArrayに共通して含まれるわけではない要素からなるArrayを返します。結果には一意の値のみが含まれます。
*2 つを超える集合*の対称差は、[数学的には](https://en.wikipedia.org/wiki/Symmetric_difference#n-ary_symmetric_difference)
奇数個の入力集合に現れるすべての入力要素からなる集合として定義されます。
一方、関数 `arraySymmetricDifference` は、すべての入力集合に共通して含まれるわけではない入力要素の集合を単純に返します。
**構文**
```sql theme={null}
arraySymmetricDifference(arr1, arr2, ... , arrN)
```
**引数**
* `arrN` — 新しいArrayの作成元となる N 個のArray。[`Array(T)`](/docs/ja/reference/data-types/array)。
**戻り値**
すべてのソースArrayに共通して含まれない、重複のない要素からなるArrayを返します [`Array(T)`](/docs/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] │
└────────────────────────────┴────────────────────────────────┘
```
## arrayTopK
導入バージョン: v26.6.0
入力配列から大きい要素を上位 K 個取り出し、降順にソートされた配列を返します。
ラムダ関数 `f` が指定されている場合、各要素に `f` を適用した結果に基づいて要素が比較されます。
`f` が複数の引数を受け取る場合は、追加の配列が `arrayTopK` に渡され、それらの要素が
`f` の引数に対応します。
`NULL` 値はスキップされ、結果には含まれません。結果のサイズは最大 `K` で、
入力配列に `K` 個未満の非 NULL 要素しか含まれていない場合は、それより小さくなることがあります。
結果の要素型は、入力要素型に対応する非 Nullable 型です。
`arrayTopK` は [高階関数](/docs/ja/reference/functions/regular-functions/overview#higher-order-functions) です。
代わりに、最も小さい要素を下位 K 個返す `arrayBottomK` も参照してください。
**構文**
```sql theme={null}
arrayTopK([f,] K, arr [, arr1, ... ,arrN])
```
**引数**
* `f(arr[, arr1, ... ,arrN])` — 省略可能。各要素のソートキーを計算するためのラムダ関数。[`ラムダ関数`](/docs/ja/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `K` — 返す最大要素数。[`(U)Int8/16/32/64`](/docs/ja/reference/data-types/int-uint)
* `arr` — 配列。[`Array(T)`](/docs/ja/reference/data-types/array)
* `arr1, ... ,arrN` — `f` が複数の引数を受け取る場合の、追加の `N` 個の配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
`arr` のうち値が大きい要素 (またはラムダ関数の結果が大きい要素) を最大 `K` 個まで、降順にソートして返します。
`NULL` はスキップされます。返される配列の要素型は、入力が `Nullable(T)` 型の場合でも `T` です。
**例**
**simple\_int**
```sql title=Query theme={null}
SELECT arrayTopK(3, [1, 5, 2, 7, 3])
```
```response title=Response theme={null}
[7,5,3]
```
**skip\_nulls**
```sql title=Query theme={null}
SELECT arrayTopK(3, [1, NULL, 5, 2, NULL, 7])
```
```response title=Response theme={null}
[7,5,2]
```
**fewer\_than\_k**
```sql title=Query theme={null}
SELECT arrayTopK(5, [1, NULL, 2])
```
```response title=Response theme={null}
[2,1]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayTopK((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1,3]
```
**lambda\_multi**
```sql title=Query theme={null}
SELECT arrayTopK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])
```
```response title=Response theme={null}
['a','c']
```
## arrayTranspose
導入バージョン: v26.4.0
二次元配列を転置します。
すべての内部配列は同じ長さである必要があります。
**構文**
```sql theme={null}
arrayTranspose(arr)
```
**引数**
* `arr` — 転置する二次元配列。すべての内部配列は同じ長さである必要があります。[`Array(Array(T))`](/docs/ja/reference/data-types/array)
**戻り値**
結果の要素 `[i][j]` が入力の要素 `[j][i]` に等しくなる、転置後の二次元配列。[`Array(Array(T))`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
ソース配列内の一意な要素からなる配列を返します [`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `[, arr2, ..., arrN]` — 任意。複数の Array の対応する位置にある要素から構成される、一意な タプル の数を数えるための追加の Array。 [`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
引数が 1 つの場合は、一意な
要素数を返します。引数が複数ある場合は、各 Array の対応する位置にある要素から構成される一意な タプル の数を返します。
[`UInt32`](/docs/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*`](/docs/ja/reference/data-types/int-uint)
* `x` — 配列の `N` 個の要素の値。型は任意です。
**戻り値**
値 `x` の `N` 個の要素で構成される Array を返します。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
ソース配列の要素をタプルにまとめた配列を返します。タプル内のデータ型は入力配列の型と同じで、配列が渡された順序と同じ順に並びます [`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
ソース配列の要素をタプルとしてまとめた配列を返します。タプル内のデータ型は入力配列の型と同じで、配列を渡した順序もそのまま保持されます。[`Array(T)`](/docs/ja/reference/data-types/array) または [`Tuple(T1, T2, ...)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `x` — 配列内で個数を数える値。任意の型。
**戻り値**
配列内で `x` に等しい要素の数を返します。[`UInt64`](/docs/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` 設定](/docs/ja/reference/settings/session-settings#optimize_functions_to_subcolumns)を有効にすることで最適化できます。`optimize_functions_to_subcolumns = 1` の場合、この関数は配列カラム全体を読み取って処理する代わりに、[size0](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
空のArrayの場合は `1`、空でないArrayの場合は `0` を返します。[`UInt8`](/docs/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)`](/docs/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)`](/docs/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)`](/docs/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)`](/docs/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)`](/docs/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)`](/docs/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)`](/docs/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()
```
**引数**
* なし。
**戻り値**
空のInt8Array。[`Array(T)`](/docs/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayInt8()
```
```response title=Response theme={null}
[]
```
## emptyArrayString
導入バージョン: v1.1.0
空のStringArrayを返します
**構文**
```sql theme={null}
emptyArrayString()
```
**引数**
* なし。
**戻り値**
空の String Array。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
Array のデフォルト型の値を 1 つ持つ配列。[`Array(T)`](/docs/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 のArrayを返します
**構文**
```sql theme={null}
emptyArrayUInt16()
```
**引数**
* なし。
**戻り値**
UInt16 の空のArray。 [`Array(T)`](/docs/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。[`Array(T)`](/docs/ja/reference/data-types/array)
**例**
**使用例**
```sql title=Query theme={null}
SELECT emptyArrayUInt32()
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt64
導入バージョン: v1.1.0
空の UInt64 Arrayを返します
**構文**
```sql theme={null}
emptyArrayUInt64()
```
**引数**
* なし。
**戻り値**
空の UInt64 のArrayです。[`Array(T)`](/docs/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)`](/docs/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`](/docs/ja/reference/data-types/array) または [`Map`](/docs/ja/reference/data-types/map) または [`JSON`](/docs/ja/reference/data-types/newjson)
* `needle` — 検索する値 (配列内の要素、Map のキー、または JSON のパス文字列) 。
**戻り値**
`haystack` に指定した `needle` が含まれている場合は `1`、含まれていない場合は `0` を返します。[`UInt8`](/docs/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)`](/docs/ja/reference/data-types/array)
* `subset` — `set` と共通のスーパータイプを持ち、`set` の部分集合かどうかを判定する対象の要素を含む、任意の型の Array。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `arr_y` — Array `arr_x` と共通スーパータイプを持つ任意の型の Array。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array)
* `arr2` — 要素の集合からなる任意の型の Array。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
配列 `arr1` が配列 `arr2` を含む場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/docs/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)`](/docs/ja/reference/data-types/array)
* `x` — `arr` 内で最初に一致する要素の値。この値に対応する索引を返します。[`UInt64`](/docs/ja/reference/data-types/int-uint)
**戻り値**
`arr` に `x` が存在する場合は、最初の `x` の索引 (1 から始まる番号) を返します。存在しない場合は `0` を返します。[`UInt64`](/docs/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)`](/docs/ja/reference/data-types/array)
* `x` — ソート済みの `arr` 内で最初に一致した要素のうち、その索引を返す対象となる値。[`UInt64`](/docs/ja/reference/data-types/int-uint)
**戻り値**
`arr` 内に `x` が存在する場合は、最初の `x` の索引 (1 から始まる) を返します。存在しない場合は、`0` を返します。[`UInt64`](/docs/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
```
## length
導入バージョン: v1.1.0
文字列またはArrayの長さを計算します。
* String または FixedString 引数の場合: 文字列のバイト数を計算します。
* Array 引数の場合: Array の要素数を計算します。
* QBit 引数の場合: ベクトルの次元を計算します。
* FixedString または QBit 引数に適用した場合、この関数は定数式になります。
文字列のバイト数は、Unicode の "code points" の数とも、
Unicode の "grapheme clusters" の数
(通常「文字」と呼ばれるもの) とも、表示上の文字幅とも一致しない点に注意してください。
文字列に ASCII の NULL バイトを含めることは可能で、それらもカウントされます。
**構文**
```sql theme={null}
length(x)
```
**別名**: `OCTET_LENGTH`, `CARDINALITY`
**引数**
* `x` — バイト数 (String/FixedString の場合)、要素数 (Array の場合)、または次元数 (QBit の場合) を計算する値。[`String`](/docs/ja/reference/data-types/string) または [`FixedString`](/docs/ja/reference/data-types/fixedstring) または [`Array(T)`](/docs/ja/reference/data-types/array) または [`QBit`](/docs/ja/reference/data-types/qbit)
**戻り値**
String/FixedString `x` のバイト数、Array `x` の要素数、または QBit `x` の次元数を返します。[`UInt64`](/docs/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
```
**QBitの例**
```sql title=Query theme={null}
SELECT length([0, 0, 0, 0, 0, 0, 0, 0]::QBit(Float32, 8))
```
```response title=Response theme={null}
8
```
**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`](/docs/ja/reference/settings/session-settings#optimize_functions_to_subcolumns) 設定を有効にすると、この関数を最適化できます。`optimize_functions_to_subcolumns = 1` の場合、この関数は Array 全体のカラムを読み取って処理する代わりに、[size0](/docs/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)`](/docs/ja/reference/data-types/array)
**戻り値**
空でない配列の場合は `1`、空の配列の場合は `0` を返します。[`UInt8`](/docs/ja/reference/data-types/int-uint)
**例**
**使用例**
```sql title=Query theme={null}
SELECT notEmpty([1,2]);
```
```response title=Response theme={null}
1
```
## randomHadamardTransform
導入バージョン: v26.7.0
浮動小数点ベクトルにランダム化 Hadamard 変換を適用します: `y = (1/sqrt(k)) * (H * D * x)`。ここで、
`D` は `seed` によって決まる決定論的な +/-1 符号の対角行列、`H` は Walsh-Hadamard
変換です。
この変換は、ベクトルのエネルギーを各座標に均等に分散させる直交な**ノルム保存**回転であり、
各座標の分布をおおむねガウス分布にし、かつ
データ非依存にします。スカラー量子化の前処理として有用であり、また --
切り詰めた場合には -- Johnson-Lindenstrauss / subsampled-randomized-Hadamard (SRHT) のランダム射影としても利用できます。
完全変換 (切り詰めなし) では、入力長はそのまま保持されます。次の長さでは厳密です:
* 2 のべき乗 (通常の高速 Walsh-Hadamard 変換) ;
* `m` が `{12, 20}` に含まれる `2^k * m` (`+/-1` Hadamard 行列を持つ次数。たとえば `768 = 64 * 12`,
`1536 = 128 * 12`, `3072 = 256 * 12`, `2560 = 128 * 20`) 。これは厳密な Kronecker 変換
`H_(2^k) (x) H_m` として適用されます (浮動小数点乗算なし) ;
* `64` 以下の、それ以外の任意の奇数 `m` に対する `2^k * m` (`+/-1` Hadamard 行列を持たない次数 --
そのような行列が存在するのは次数 `1`、`2`、および `4` の倍数のみです) 。これは厳密な Kronecker 変換
`H_(2^k) (x) C_m` として適用され、ここで `C_m` は実直交な Discrete Hartley Transform 行列です。これにより
`3584 = 512 * 7`、`1152 = 128 * 9`、`1408 = 128 * 11` のような残りの埋め込みファミリーもカバーされます。
最大の奇数因子が `64` を超える長さに対する完全変換には厳密な形がなく、より長い 2 のべき乗長への
ゼロ埋めが必要になります。そのため、黙ってより長いベクトルを返すのではなく、**例外として拒否**されます。
サポートされている長さを使用するか、`output_dims` を渡して任意長の切り詰め射影を計算してください
(下記参照) 。
結果の要素型は入力と同じです。空の入力配列を渡すと、空の配列が返されます。
* `seed` (省略可、デフォルト `0`) : 符号パターンを選択します。同じ seed では常に同じ
変換が得られます。
* `output_dims` (省略可、デフォルトは変換長) : 先頭の `output_dims`
個の座標だけを残し、この変換を **任意の** 長さを受け付けるランダム射影にします。この
`1/sqrt(output_dims)` のスケーリングにより、完全変換では結果のノルムが保存され、
切り詰め時には期待値の意味でノルムが保存されます。これは変換長を超えてはいけません。なぜなら、
Discrete Hartley 因子 `C_m` の切り詰められたプレフィックスは、`+/-1` Hadamard 行列のような
一様なレバレッジを持たないため、Hartley ファミリーの長さ (または厳密な因子を持たない任意の長さ) で
`output_dims` による切り詰めを行う場合は、ゼロ埋めした 2 のべき乗変換が使われます。こちらはその性質を保ちます。
**構文**
```sql theme={null}
randomHadamardTransform(vector[, seed[, output_dims]])
```
**引数**
* `vector` — 変換するベクトル。[`Array(BFloat16)`](/docs/ja/reference/data-types/array) または [`Array(Float32)`](/docs/ja/reference/data-types/array) または [`Array(Float64)`](/docs/ja/reference/data-types/array)
* `seed` — 省略可能。決定論的な +/-1 符号のシード (デフォルトは 0) 。[`UInt*`](/docs/ja/reference/data-types/int-uint)
* `output_dims` — 省略可能。結果を先頭からこの数の座標に切り詰めます (デフォルトは完全変換の長さ全体で、サポートされているすべての次元で入力長と同じです) 。output\_dims を指定すると、厳密な完全変換形式がない長さでも変換が有効になります。[`UInt*`](/docs/ja/reference/data-types/int-uint)
**戻り値**
変換後のベクトル (要素型は入力と同じ) 。長さは変換長 (サポートされている次元の完全変換では入力長と同じ) で、必要に応じて output\_dims まで切り詰められます。[`Array(BFloat16)`](/docs/ja/reference/data-types/array) または [`Array(Float32)`](/docs/ja/reference/data-types/array) または [`Array(Float64)`](/docs/ja/reference/data-types/array)
**例**
**2 の累乗長に対する完全変換**
```sql title=Query theme={null}
SELECT length(randomHadamardTransform([1, 2, 3, 4]::Array(Float32)))
```
```response title=Response theme={null}
4
```
**ノルムは保たれます**
```sql title=Query theme={null}
SELECT round(arraySum(x -> x * x, randomHadamardTransform([1, 2, 3, 4]::Array(Float32))) - 30, 4)
```
```response title=Response theme={null}
0
```
**3 次元に切り詰めた射影 (任意の長さを受け付けます)**
```sql title=Query theme={null}
SELECT length(randomHadamardTransform([1, 2, 3, 4, 5, 6, 7, 8]::Array(Float32), 42, 3))
```
```response title=Response theme={null}
3
```
**2^k \* m 次元の厳密変換では、入力長がそのまま保たれます (パディングなし) **
```sql title=Query theme={null}
SELECT length(randomHadamardTransform(CAST(range(1152), 'Array(Float32)')))
```
```response title=Response theme={null}
1152
```
## 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`](/docs/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)`](/docs/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`](/docs/ja/reference/data-types/index)
* `arr` — 配列。[`Array(T)`](/docs/ja/reference/data-types/array)
**戻り値**
`arr` と同じ長さで、各要素が値 `x` の配列を返します。[`Array(T)`](/docs/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)`](/docs/ja/reference/data-types/array) または [`String`](/docs/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'
```
## 距離関数
サポートされているすべての関数については、[距離関数のドキュメント](/docs/ja/reference/functions/regular-functions/distance-functions)を参照してください。