

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# 配列関数
<a name="Array_Functions"></a>

このセクションでは、 AWS Clean Roomsでサポートされている SQL の配列関数について説明します。

**Topics**
+ [ARRAY 関数](array.md)
+ [ARRAY\$1CONTAINS 関数](array_contains.md)
+ [ARRAY\$1DISTINCT 関数](array_distinct.md)
+ [ARRAY\$1EXCEPT 関数](array_except.md)
+ [ARRAY\$1INTERSECT 関数](array_intersect.md)
+ [ARRAY\$1JOIN 関数](array_join.md)
+ [ARRAY\$1REMOVE 関数](array_remove.md)
+ [ARRAY\$1UNION 関数](array_union.md)
+ [EXPLODE 関数](explode.md)
+ [FLATTEN 関数](flatten.md)

# ARRAY 関数
<a name="array"></a>

指定された要素を持つ配列を作成します。

## 構文
<a name="array-synopsis"></a>

```
ARRAY( [ expr1 ] [ , expr2 [ , ... ] ] )
```

## 引数
<a name="array-argument"></a>

 *expr1、expr2*   
日付型と時刻型を除く任意のデータ型の式。引数は同じデータ型である必要はありません。

## 戻り型
<a name="array-return-type"></a>

配列関数は、式内の要素を含む ARRAY を返します。

## 例
<a name="array-example"></a>

次の例は、数値の配列と、さまざまなデータ型の配列を示しています。

```
--an array of numeric values
select array(1,50,null,100);
      array
------------------
 [1,50,null,100]
(1 row)

--an array of different data types
select array(1,'abc',true,3.14);
        array
-----------------------
 [1,"abc",true,3.14]
(1 row)
```

# ARRAY\$1CONTAINS 関数
<a name="array_contains"></a>

ARRAY\$1CONTAINS 関数を使用して、配列データ構造に対して基本的なメンバーシップチェックを実行できます。ARRAY\$1CONTAINS 関数は、配列内に特定の値が存在するかどうかを確認する必要がある場合に便利です。

## 構文
<a name="array_contains-syntax"></a>

```
array_contains(array, value)
```

## 引数
<a name="array_contains-arguments"></a>

 *array*  
検索する ARRAY。

 *value*  
配列要素と最も一般的でない型を共有する型を持つ式。

## 戻り型
<a name="array_contains-return-type"></a>

ARRAY\$1CONTAINS 関数は BOOLEAN を返します。

値が NULL の場合、結果は NULL です。

配列内のいずれかの要素が NULL の場合、値が他の要素と一致しない場合、結果は NULL になります。

## 例
<a name="array_contains-example"></a>

次の例では、配列に値 `[1, 2, 3]`が含まれているかどうかを確認します`4`。配列 `[1, 2, 3`] には値 が含まれていないため`4`、array\$1contains 関数は を返します`false`。

```
SELECT array_contains(array(1, 2, 3), 4)
false
```

次の例では、配列に値 `[1, 2, 3]`が含まれているかどうかを確認します`2`。配列`[1, 2, 3]`には値 が含まれているため`2`、array\$1contains 関数は を返します`true`。

```
SELECT array_contains(array(1, 2, 3), 2);
 true
```

# ARRAY\$1DISTINCT 関数
<a name="array_distinct"></a>

ARRAY\$1DISTINCT 関数を使用して、配列から重複した値を削除できます。ARRAY\$1DISTINCT 関数は、配列から重複を削除し、一意の要素のみを操作する必要がある場合に便利です。これは、繰り返し値が干渉されることなくデータセットに対してオペレーションまたは分析を実行するシナリオに役立ちます。

## 構文
<a name="array_distinct-syntax"></a>

```
array_distinct(array)
```

## 引数
<a name="array_distinct-arguments"></a>

 *array*  
ARRAY 式。

## 戻り型
<a name="array_distinct-return-type"></a>

ARRAY\$1DISTINCT 関数は、入力配列の一意の要素のみを含む ARRAY を返します。

## 例
<a name="array_distinct-example"></a>

この例では、入力配列に の重複値`[1, 2, 3, null, 3]`が含まれています`3`。`array_distinct` 関数はこの重複した値を削除`3`し、一意の要素 を持つ新しい配列を返します`[1, 2, 3, null]`。

```
SELECT array_distinct(array(1, 2, 3, null, 3));
 [1,2,3,null]
```

この例では、入力配列に `2`と の重複した値`[1, 2, 2, 3, 3, 3]`が含まれています`3`。`array_distinct` 関数はこれらの重複を削除し、一意の要素 を持つ新しい配列を返します`[1, 2, 3]`。

```
SELECT array_distinct(array(1, 2, 2, 3, 3, 3))
  [1,2,3]
```

# ARRAY\$1EXCEPT 関数
<a name="array_except"></a>

ARRAY\$1EXCEPT 関数は 2 つの配列を引数として受け取り、最初の配列に存在する要素のみを含む新しい配列を返しますが、2 番目の配列は含みません。

ARRAY\$1EXCEPT は、ある配列と別の配列に固有の要素を見つける必要がある場合に便利です。これは、2 つのデータセットの違いを見つけるなど、配列に対してセットのようなオペレーションを実行する必要がある場合に役立ちます。

## 構文
<a name="array_except-syntax"></a>

```
array_except(array1, array2)
```

## 引数
<a name="array_except-arguments"></a>

 *array1*  
同等の要素を持つ任意のタイプの ARRAY。

 *array2*  
array*1* の要素と最小共通タイプを共有する要素の ARRAY。

## 戻り型
<a name="array_except-return-type"></a>

ARRAY\$1EXCEPT 関数は、重複することなく*、配列 1* に一致するタイプの ARRAY を返します。

## 例
<a name="array_except-example"></a>

この例では、最初の配列に要素 1、2、3 `[1, 2, 3]`が含まれています。2 番目の配列には、要素 2、3、および 4 `[2, 3, 4]`が含まれています。この`array_except`関数は、2 番目の配列にも存在するため、最初の配列から要素 2 と 3 を削除します。結果の出力は配列 です`[1]`。

```
SELECT array_except(array(1, 2, 3), array(2, 3, 4))
  [1]
```

この例では、最初の配列に要素 1、2、3 `[1, 2, 3]`が含まれています。2 番目の配列には、要素 1、3、5 `[1, 3, 5]`が含まれます。`array_except` 関数は、2 番目の配列にも存在するため、最初の配列から要素 1 と 3 を削除します。結果の出力は配列 です`[2]`。

```
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
 [2]
```

# ARRAY\$1INTERSECT 関数
<a name="array_intersect"></a>

ARRAY\$1INTERSECT 関数は 2 つの配列を引数として受け取り、両方の入力配列に存在する要素を含む新しい配列を返します。この関数は、2 つの配列間で共通の要素を見つける必要がある場合に便利です。これは、2 つのデータセット間の交差を見つけるなど、配列に対してセットのようなオペレーションを実行する必要がある場合に役立ちます。

## 構文
<a name="array_intersect-syntax"></a>

```
array_intersect(array1, array2)
```

## 引数
<a name="array_intersect-arguments"></a>

 *array1*  
同等の要素を持つ任意のタイプの ARRAY。

 *array2*  
array1 の要素と最小共通タイプを共有する要素の ARRAY。

## 戻り型
<a name="array_intersect-return-type"></a>

ARRAY\$1INTERSECT 関数は、配列 1 と配列 2 の両方に含まれる重複や要素なしで、配列 1 に一致するタイプの ARRAY を返します。

## 例
<a name="array_intersect-example"></a>

この例では、最初の配列に要素 1、2、3 `[1, 2, 3]`が含まれています。2 番目の配列には、要素 1、3、5 `[1, 3, 5]`が含まれます。ARRAY\$1INTERSECT 関数は、1 と 3 の 2 つの配列間の共通要素を識別します。結果の出力配列は です`[1, 3]`。

```
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
 [1,3]
```

# ARRAY\$1JOIN 関数
<a name="array_join"></a>

ARRAY\$1JOIN 関数は 2 つの引数を取ります。最初の引数は、結合される入力配列です。2 番目の引数は、配列要素の連結に使用される区切り文字列です。この関数は、文字列の配列 (またはその他のデータ型) を 1 つの連結文字列に変換する必要がある場合に便利です。これは、表示目的や今後の処理など、値の配列を単一の形式の文字列として表示する場合に役立ちます。

## 構文
<a name="array_join-syntax"></a>

```
array_join(array, delimiter[, nullReplacement])
```

## 引数
<a name="array_join-arguments"></a>

 *array*  
任意の ARRAY 型、ただしその要素は文字列として解釈されます。

 *delimiter*  
連結された配列要素を分離するために使用される STRING。

 *nullReplacement*  
結果で NULL 値を表すために使用される STRING。

## 戻り型
<a name="array_join-return-type"></a>

ARRAY\$1JOIN 関数は、配列の要素が区切り文字で区切られ、null 要素が に置き換えられる STRING を返します`nullReplacement`。`nullReplacement` を省略すると、`null`要素は除外されます。引数が の場合`NULL`、結果は です`NULL`。

## 例
<a name="array_join-example"></a>

この例では、ARRAY\$1JOIN 関数は配列`['hello', 'world']`を取得し、区切り文字 `' '` (スペース文字) を使用して要素を結合します。結果の出力は文字列 です`'hello world'`。

```
SELECT array_join(array('hello', 'world'), ' ');
 hello world
```

この例では、ARRAY\$1JOIN 関数は配列`['hello', null, 'world']`を取得し、区切り文字 `' '` (スペース文字) を使用して要素を結合します。`null` 値は、指定された置換文字列 `','` (カンマ) に置き換えられます。結果の出力は文字列 です`'hello , world'`。

```
SELECT array_join(array('hello', null ,'world'), ' ', ',');
 hello , world
```

# ARRAY\$1REMOVE 関数
<a name="array_remove"></a>

ARRAY\$1REMOVE 関数は 2 つの引数を取ります。最初の引数は、要素が削除される入力配列です。2 番目の引数は、配列から削除される値です。この関数は、配列から特定の要素を削除する必要がある場合に便利です。これは、値の配列に対してデータクリーニングまたは前処理を実行する必要がある場合に役立ちます。

## 構文
<a name="array_remove-syntax"></a>

```
array_remove(array, element)
```

## 引数
<a name="array_remove-arguments"></a>

 *array*  
ARRAY。

 *element*  
配列の要素と最も一般的でない型を共有する型の式。

## 戻り型
<a name="array_remove-return-type"></a>

ARRAY\$1REMOVE 関数は、配列のタイプに一致する結果タイプを返します。削除する要素が の場合`NULL`、結果は です`NULL`。

## 例
<a name="array_remove-example"></a>

この例では、ARRAY\$1REMOVE 関数は 配列`[1, 2, 3, null, 3]`を取得し、値 3 のすべての出現を削除します。結果の出力は配列 です`[1, 2, null]`。

```
SELECT array_remove(array(1, 2, 3, null, 3), 3);
 [1,2,null]
```

# ARRAY\$1UNION 関数
<a name="array_union"></a>

ARRAY\$1UNION 関数は 2 つの配列を引数として受け取り、両方の入力配列の一意の要素を含む新しい配列を返します。この関数は、2 つの配列を組み合わせて重複要素を排除する必要がある場合に便利です。これは、2 つのデータセット間の結合を見つけるなど、配列に対してセットのようなオペレーションを実行する必要がある場合に役立ちます。

## 構文
<a name="array_union-syntax"></a>

```
array_union(array1, array2)
```

## 引数
<a name="array_union-arguments"></a>

 *array1*  
ARRAY。

 *array2*  
*array1* と同じタイプの ARRAY。

## 戻り型
<a name="array_union-return-type"></a>

ARRAY\$1UNION 関数は、配列と同じタイプの ARRAY を返します。

## 例
<a name="array_union-example"></a>

この例では、最初の配列に要素 1、2、3 `[1, 2, 3]`が含まれています。2 番目の配列には、要素 1、3、5 `[1, 3, 5]`が含まれます。ARRAY\$1UNION 関数は、両方の配列の一意の要素を組み合わせて、出力配列 を生成します`[1, 2, 3, 5]`。T

```
SELECT array_union(array(1, 2, 3), array(1, 3, 5));
 [1,2,3,5]
```

# EXPLODE 関数
<a name="explode"></a>

EXPLODE 関数は、配列またはマップ列を持つ単一の行を複数の行に変換するために使用されます。各行は配列またはマップの単一の要素に対応します。

## 構文
<a name="explode-syntax"></a>

```
explode(expr)
```

## 引数
<a name="explode-arguments"></a>

 expr**  
配列式またはマップ式。

## 戻り型
<a name="explode-return-type"></a>

EXPLODE 関数は行のセットを返します。各行は入力配列またはマップの 1 つの要素を表します。

出力行のデータ型は、入力配列またはマップ内の要素のデータ型によって異なります。

## 例
<a name="explode-example"></a>

次の例では、単一行配列 [10, 20] を取得し、それぞれ配列要素 (10 と 20) の 1 つを含む 2 つの別々の行に変換します。

```
SELECT explode(array(10, 20));
```

最初の例では、入力配列が引数として に直接渡されました`explode()`。この例では、入力配列は `=>`構文を使用して指定されます。ここで、列名 (`collection`) は明示的に指定されます。

```
SELECT explode(array(10, 20));
```

どちらのアプローチも有効であり、同じ結果が得られますが、2 番目の構文は、単純な配列リテラルではなく、より大きなデータセットから列を爆発させる必要がある場合に便利です。

# FLATTEN 関数
<a name="flatten"></a>

FLATTEN 関数は、ネストされた配列構造を単一のフラット配列に「フラット化」するために使用されます。

## 構文
<a name="flatten-syntax"></a>

```
flatten(arrayOfArrays)
```

## 引数
<a name="flatten-arguments"></a>

 *arrayOfArrays*  
配列の配列。

## 戻り型
<a name="flatten-return-type"></a>

FLATTEN 関数は配列を返します。

## 例
<a name="flatten-example"></a>

この例では、入力は 2 つの内部配列を持つネストされた配列であり、出力は内部配列のすべての要素を含む単一のフラット配列です。FLATTEN 関数は、ネストされた配列 `[[1, 2], [3, 4]]`を取得し、すべての要素を 1 つの配列 に結合します`[1, 2, 3, 4]`。

```
SELECT flatten(array(array(1, 2), array(3, 4)));
 [1,2,3,4]
```