構造化データ型¶

構造化 ARRAY の指定¶

構造化 ARRAY を指定するには、次の構文を使用します。

ARRAY( <element_type> [ NOT NULL ] )

条件:

• element_type はこの ARRAY の要素の Snowflakeデータ型 です。

  要素の型として、構造化 ARRAY、構造化 OBJECT、または MAP を指定することもできます。

  注釈

  Icebergテーブル列の定義では、 ARRAY 要素の型として VARIANT、半構造化 ARRAY、または半構造化 OBJECT を指定することはできません。

• NOT NULL は ARRAY が NULL の要素を含むことができないことを指定します。

例えば、次のステートメントで SYSTEM$TYPEOF 関数が返す型を比較します。

• 最初の列式は、半構造化 ARRAY を構造化 ARRAY （NUMBER 要素の ARRAY）にキャストします。

• 2番目の列式は半構造化 ARRAY を指定します。

SELECT
  SYSTEM$TYPEOF(
    [1, 2, 3]::ARRAY(NUMBER)
  ) AS structured_array,
  SYSTEM$TYPEOF(
    [1, 2, 3]
  ) AS semi_structured_array;

+-------------------------------+-----------------------+
| STRUCTURED_ARRAY              | SEMI_STRUCTURED_ARRAY |
|-------------------------------+-----------------------|
| ARRAY(NUMBER(38,0))[LOB]      | ARRAY[LOB]            |
+-------------------------------+-----------------------+

構造化 OBJECT の指定¶

構造化 OBJECT を指定するには、次の構文を使用します。

OBJECT(
  [
    <key> <value_type> [ NOT NULL ]
    [ , <key> <value_type> [ NOT NULL ] ]
    [ , ... ]
  ]
)

条件:

• key は OBJECT のキーを指定します。

  • オブジェクト定義の各 key は一意である必要があります。

  • キーの順序はオブジェクト定義の一部です。同じキーを持つ2つの OBJECTs を異なる順序で比較することは許可されていません。（コンパイル時にエラーが発生します）。

  • キーを指定せずに括弧を指定した場合（つまり OBJECT() を使用した場合）、結果として得られる型は、キーを含まない構造化 OBJECT になります。キーを持たない構造化 OBJECT は、半構造化 OBJECT とは異なります。

• value_type は、キーに対応する値の Snowflakeデータ型 です。

  値の型として、構造化 ARRAY、構造化 OBJECT、または MAP を指定することもできます。

  注釈

  Icebergテーブルの列の定義では、 OBJECT キーに対応する値の型として VARIANT、半構造化 ARRAY、または半構造化 OBJECT を指定することはできません。

• NOT NULL は、キーに対応する値は NULL にできないことを指定します。

例えば、次のステートメントで SYSTEM$TYPEOF 関数が返す型を比較します。

• 最初の列式は、半構造化 OBJECT を、以下のキーと値を含む構造化 OBJECT にキャストします。

  • NULL ではない VARCHAR 値を持つ str という名前のキー。

  • NUMBER 値を持つ num という名前のキー。

• 2番目の列式は半構造化 OBJECT を指定します。

SELECT
  SYSTEM$TYPEOF(
    {
      'str': 'test',
      'num': 1
    }::OBJECT(
      str VARCHAR NOT NULL,
      num NUMBER
    )
  ) AS structured_object,
  SYSTEM$TYPEOF(
    {
      'str': 'test',
      'num': 1
    }
  ) AS semi_structured_object;

+----------------------------------------------------------------+------------------------+
| STRUCTURED_OBJECT                                              | SEMI_STRUCTURED_OBJECT |
|----------------------------------------------------------------+------------------------|
| OBJECT(str VARCHAR(16777216), num NUMBER(38,0) NOT NULL )[LOB] | OBJECT[LOB]            |
+----------------------------------------------------------------+------------------------+

MAP の指定¶

MAP を指定するには、次の構文を使用します。

MAP( <key_type> , <value_type> [ NOT NULL ] )

条件:

• key_type は、マップの Snowflake データ型 のキーです。次のいずれかの型をキーに使用する必要があります。

  • VARCHAR

  • スケール0の NUMBER

  浮動小数点データ型をキーの型として使うことはできません。

  マップのキーは NULL にはできないことに注意してください。

• value_type は、マップ内の値の Snowflakeデータ型 です。

  値の型として、構造化 ARRAY、構造化 OBJECT、または MAP を指定することもできます。

  注釈

  Icebergテーブル列の定義では、MAP の値の型として VARIANT、半構造化 ARRAY、または半構造化 OBJECT を指定することはできません。

• NOT NULL は、キーに対応する値は NULL にできないことを指定します。NOT NULL は値を NULL にできないことを指定します。

次の例では、半構造化 OBJECT を MAP にキャストし、 SYSTEM$TYPEOF 関数を使用してその結果のオブジェクトの型を表示します。MAP は VARCHAR キーと VARCHAR 値を関連付けます。

SELECT
  SYSTEM$TYPEOF(
    {
      'a_key': 'a_val',
      'b_key': 'b_val'
    }::MAP(VARCHAR, VARCHAR)
  ) AS map_example;

+------------------------------------------------+
| MAP_EXAMPLE                                    |
|------------------------------------------------|
| map(VARCHAR(16777216), VARCHAR(16777216))[LOB] |
+------------------------------------------------+

半構造化型を構造化型に明示的にキャストする¶

半構造化オブジェクトを構造化型に明示的にキャストするには、 CAST 関数を呼び出すか、::演算子を使用 できます。

次の半構造化オブジェクトは、対応する構造化型にのみキャストできます。それ以外の場合は、ランタイムエラーが発生します。

次のセクションでは、どのように型がキャスティングされるかについて詳しく説明します。

• 半構造化 ARRAYs と VARIANTs の構造化 ARRAYs へのキャスト

• 半構造化 OBJECTs と VARIANTs の構造化 OBJECTs へのキャスト

• 半構造化 OBJECTs と VARIANTs の MAPs へのキャスト

SELECT
  SYSTEM$TYPEOF(
    CAST ([1,2,3] AS ARRAY(NUMBER))
  ) AS array_cast_type,
  SYSTEM$TYPEOF(
    CAST ([1,2,3]::VARIANT AS ARRAY(NUMBER))
  ) AS variant_cast_type;

SELECT
  SYSTEM$TYPEOF(
    [1,2,3]::ARRAY(NUMBER)
  ) AS array_cast_type,
  SYSTEM$TYPEOF(
    [1,2,3]::VARIANT::ARRAY(NUMBER)
  ) AS variant_cast_type;

+--------------------------+--------------------------+
| ARRAY_CAST_TYPE          | VARIANT_CAST_TYPE        |
|--------------------------+--------------------------|
| ARRAY(NUMBER(38,0))[LOB] | ARRAY(NUMBER(38,0))[LOB] |
+--------------------------+--------------------------+

SELECT
  SYSTEM$TYPEOF(
    CAST ({'city':'San Mateo','state':'CA'} AS OBJECT(city VARCHAR, state VARCHAR))
  ) AS object_cast_type,
  SYSTEM$TYPEOF(
    CAST ({'city':'San Mateo','state':'CA'}::VARIANT AS OBJECT(city VARCHAR, state VARCHAR))
  ) AS variant_cast_type;

SELECT
  SYSTEM$TYPEOF(
     {'city':'San Mateo','state':'CA'}::OBJECT(city VARCHAR, state VARCHAR)
  ) AS object_cast_type,
  SYSTEM$TYPEOF(
     {'city':'San Mateo','state':'CA'}::VARIANT::OBJECT(city VARCHAR, state VARCHAR)
  ) AS variant_cast_type;

+--------------------------------------------------------------+--------------------------------------------------------------+
| OBJECT_CAST_TYPE                                             | VARIANT_CAST_TYPE                                            |
|--------------------------------------------------------------+--------------------------------------------------------------|
| OBJECT(city VARCHAR(16777216), state VARCHAR(16777216))[LOB] | OBJECT(city VARCHAR(16777216), state VARCHAR(16777216))[LOB] |
+--------------------------------------------------------------+--------------------------------------------------------------+

SELECT
  SYSTEM$TYPEOF(
    CAST ({'my_key':'my_value'} AS MAP(VARCHAR, VARCHAR))
  ) AS map_cast_type,
  SYSTEM$TYPEOF(
    CAST ({'my_key':'my_value'} AS MAP(VARCHAR, VARCHAR))
  ) AS variant_cast_type;

SELECT
  SYSTEM$TYPEOF(
    {'my_key':'my_value'}::MAP(VARCHAR, VARCHAR)
  ) AS map_cast_type,
  SYSTEM$TYPEOF(
    {'my_key':'my_value'}::VARIANT::MAP(VARCHAR, VARCHAR)
  ) AS variant_cast_type;

+------------------------------------------------+------------------------------------------------+
| MAP_CAST_TYPE                                  | VARIANT_CAST_TYPE                              |
|------------------------------------------------+------------------------------------------------|
| map(VARCHAR(16777216), VARCHAR(16777216))[LOB] | map(VARCHAR(16777216), VARCHAR(16777216))[LOB] |
+------------------------------------------------+------------------------------------------------+

構造化型を半構造化型に明示的にキャストする¶

構造化型を半構造化型に明示的にキャストするには、 CAST 関数を呼び出すか、::演算子を使用するか、変換関数の1つ（例えば、 TO_ARRAY、 TO_OBJECT、 TO_VARIANT）を呼び出します。

例:

• col_structured_array が ARRAY(VARCHAR) の場合、

  • CAST(col_structured_array AS ARRAY) は半構造化 ARRAY を返します。

  • CAST(col_structured_array AS VARIANT) は半構造化 ARRAY を保持する VARIANT を返す。

• col_structured_object が OBJECT(name VARCHAR, state VARCHAR) の場合、

  • CAST(col_structured_object AS OBJECT) は半構造化 OBJECT を返します。

  • CAST(col_structured_object AS VARIANT) は半構造化 OBJECT を保持する VARIANT を返します。

• col_map が MAP(VARCHAR, VARCHAR) の場合、

  • CAST(col_map AS OBJECT) は半構造化 OBJECT を返します。

  • CAST(col_map AS VARIANT) は半構造化 OBJECT を保持する VARIANT を返します。

次の点に注意してください。

• 半構造化 OBJECT にキャストする場合、構造化 OBJECT 内のキーの順序は保持されません。

• 構造化 OBJECT または MAP を半構造化 OBJECT または VARIANT にキャストする場合、NULL 値はすべて JSON null値 に変換されます。

  構造化 ARRAY を VARIANT にキャストする場合、NULL の値はそのまま保持されます。

  SELECT [1,2,NULL,3]::ARRAY(INTEGER)::VARIANT;
  

  Copy

  +---------------------------------------+
  | [1,2,NULL,3]::ARRAY(INTEGER)::VARIANT |
  |---------------------------------------|
  | [                                     |
  |   1,                                  |
  |   2,                                  |
  |   undefined,                          |
  |   3                                   |
  | ]                                     |
  +---------------------------------------+
  

• キーに NUMBER 型を使用する MAP をキャストする場合、MAP キーは返される OBJECT 内で文字列に変換されます。

値の暗黙のキャスト（強制）¶

ある構造化型から別の構造化型への 暗黙のキャスト（強制） には次のルールが適用されます。

• 構造化型は、2つの基本オブジェクト型が同じであれば、別の構造化型に強制することができます。

  • 1つの型の ARRAY は、最初の要素型が2番目の要素型に強制可能であれば、別の型の ARRAY に強制することができます。

    要素型は次のいずれかの場合で別の要素型に強制できます。

    • どちらの型も数値である。次のケースがサポートされています。

      • どちらも同じ数値型を使用しているけれども、精度やスケールが異なる可能性がある。

      • NUMBER を FLOAT に強制する（逆も同様）。

    • どちらの型もタイムスタンプである。次のケースがサポートされています。

      • どちらも同じ型を使用しているけれども、精度が異なる可能性がある。

      • TIMESTAMP_LTZ を TIMESTAMP_TZ に強制する（逆も同様）。

    例:

    • ARRAY(NUMBER) を ARRAY(DOUBLE) に強制できる。

    • ARRAY(DATE) を ARRAY(NUMBER) に強制できない。

  • 1つの型定義を持つ OBJECT を、別の型定義を持つ OBJECT に強制することができるのは、次のすべてが正しい場合に限られます。

    • どちらの OBJECT 型も同じ数のキーを持っている。

    • どちらの OBJECT 型もキーに同じ名前を使用している。

    • 両方の OBJECT 型のキーが同じ順番である。

    • 一方の OBJECT 型の各値の型は、もう一方の OBJECT 型の対応する値の型に強制することができる。

      構造化 ARRAYs の要素型の場合と同様に、ある値の型を別の型に強制できるのは次の場合だけです。

      • どちらの型も数値である。次のケースがサポートされています。

        • どちらも同じ数値型を使用しているけれども、精度やスケールが異なる可能性がある。

        • NUMBER を FLOAT に強制する（逆も同様）。

      • どちらの型もタイムスタンプである。次のケースがサポートされています。

        • どちらも同じ型を使用しているけれども、精度が異なる可能性がある。

        • TIMESTAMP_LTZ を TIMESTAMP_TZ に強制する（逆も同様）。

    例:

    • OBJECT(city VARCHAR, zipcode NUMBER) を OBJECT(city VARCHAR, zipcode DOUBLE) に強制することができる。

    • OBJECT(city VARCHAR, zipcode NUMBER) を OBJECT(city VARCHAR, zipcode DATE) に強制することはできない。

  • 1つの値型を持つ MAP は、次の場合に異なる値型を持つ MAP に強制することができる。

    • どちらも数値型である。次のケースがサポートされています。

      • どちらも同じ数値型を使用しているけれども、精度やスケールが異なる可能性がある。

      • NUMBER を FLOAT に強制する（逆も同様）。

    • どちらの値もタイムスタンプである。次のケースがサポートされています。

      • どちらも同じ型を使用しているけれども、精度が異なる可能性がある。

      • TIMESTAMP_LTZ を TIMESTAMP_TZ に強制する（逆も同様）。

    例えば、MAP(VARCHAR, NUMBER) をMAP(VARCHAR, DOUBLE) に強制することができます。

  • 1つのキー型を持つ MAP は、両方のキー型が精度のみが異なる同じ整数 NUMERIC 型を使用する場合に異なるキー型を持つ MAP に強制することができます。

    例えば、MAP(VARCHAR, NUMBER) をMAP(NUMBER, NUMBER) に強制することはできません。

• 構造化型を半構造化オブジェクトに強制することはできない（その逆も同様）。

• 値 VARCHAR を構造化型に強制することはできない。

ある構造化型から別の構造型へのキャスト¶

ある構造化型から別の構造化型にキャストするには、 CAST 関数を呼び出すか、::演算子 を使用します。次の構造化型から、または構造化型へキャストできます。

• 構造化 ARRAYs の場合:

  ある型の ARRAY を別の型の ARRAY にキャストできます。

• 構造化 OBJECTs の場合:

  • キャストを使用して、OBJECT 内の キーと値のペアの順序を変更 できます。

  • キャストを使用して、OBJECT 内の キーの名前を変更 できます。

  • キャストを使用して、OBJECT に キーを追加 できます。

  • 構造化 OBJECT を MAP にキャストできます。

• MAPs の場合:

  • 特定の型のキーと値を持つ MAP を、異なる型のキーと値を持つ MAP にキャストできます。

  • MAP を構造化 OBJECT にキャストできます。

一方の型からもう一方の型に値をキャストできない場合、キャストは失敗します。例えば、ARRAY(BOOLEAN) を ARRAY(DATE) にキャストしようとすると失敗します。

SELECT CAST(
  CAST([1,2,3] AS ARRAY(NUMBER))
  AS ARRAY(VARCHAR)
);

SELECT CAST(
  {'city': 'San Mateo','state': 'CA'}::OBJECT(city VARCHAR, state VARCHAR)
  AS OBJECT(state VARCHAR, city VARCHAR)
);

SELECT CAST({'city':'San Mateo','state': 'CA'}::OBJECT(city VARCHAR, state VARCHAR)
  AS OBJECT(city_name VARCHAR, state_name VARCHAR) RENAME FIELDS);

+------------------------------------------------------------------------------+
| CAST({'CITY':'SAN MATEO','STATE': 'CA'}::OBJECT(CITY VARCHAR, STATE VARCHAR) |
|   AS OBJECT(CITY_NAME VARCHAR, STATE_NAME VARCHAR) RENAME FIELDS)            |
|------------------------------------------------------------------------------|
| {                                                                            |
|   "city_name": "San Mateo",                                                  |
|   "state_name": "CA"                                                         |
| }                                                                            |
+------------------------------------------------------------------------------+

SELECT CAST({'city':'San Mateo','state': 'CA'}::OBJECT(city VARCHAR, state VARCHAR)
  AS OBJECT(city VARCHAR, state VARCHAR, zipcode NUMBER) ADD FIELDS);

+------------------------------------------------------------------------------+
| CAST({'CITY':'SAN MATEO','STATE': 'CA'}::OBJECT(CITY VARCHAR, STATE VARCHAR) |
|   AS OBJECT(CITY VARCHAR, STATE VARCHAR, ZIPCODE NUMBER) ADD FIELDS)         |
|------------------------------------------------------------------------------|
| {                                                                            |
|   "city": "San Mateo",                                                       |
|   "state": "CA",                                                             |
|   "zipcode": null                                                            |
| }                                                                            |
+------------------------------------------------------------------------------+

SQL 関数を使用した構造化 ARRAYs と OBJECTs の構築¶

次の関数は半構造化 ARRAYs を構築します。

• ARRAY_CONSTRUCT

• ARRAY_CONSTRUCT_COMPACT

• ARRAY_AGG

• TO_ARRAY

次の関数は半構造化 OBJECTs を構築します。

• OBJECT_CONSTRUCT

• OBJECT_CONSTRUCT_KEEP_NULL

• OBJECT_AGG

• TO_OBJECT

構造化 ARRAY または OBJECT を構築するには、これらの関数を使用し、関数の戻り値を明示的にキャストします。例:

SELECT ARRAY_CONSTRUCT(10, 20, 30)::ARRAY(NUMBER);

SELECT OBJECT_CONSTRUCT(
  'name', 'abc',
  'created_date', '2020-01-18'::DATE
)::OBJECT(
  name VARCHAR,
  created_date DATE
);

詳細については、 半構造化型を構造化型に明示的にキャストする をご参照ください。

ARRAY と OBJECT 定数を使用した構造化 ARRAYs と OBJECTs の構築¶

ARRAY 定数 または OBJECT 定数 を指定する場合、半構造化 ARRAY または OBJECT を指定していることになります。

構造化 ARRAY または OBJECT を構築するには、式を明示的にキャストする必要があります。例:

SELECT [10, 20, 30]::ARRAY(NUMBER);

SELECT {
  'name': 'abc',
  'created_date': '2020-01-18'::DATE
}::OBJECT(
  name VARCHAR,
  created_date DATE
);

詳細については、 半構造化型を構造化型に明示的にキャストする をご参照ください。

MAP の構築¶

MAP を構築するには、半構造化オブジェクトを構築し、 OBJECT を MAP にキャストします。

例えば、次のステートメントはどちらも MAP {'city'->'San Mateo','state'->'CA'} を生成します。

SELECT OBJECT_CONSTRUCT(
  'city', 'San Mateo',
  'state', 'CA'
)::MAP(
  VARCHAR,
  VARCHAR
);

SELECT {
  'city': 'San Mateo',
  'state': 'CA'
}::MAP(
  VARCHAR,
  VARCHAR
);

次のステートメントは MAP {-10->'CA',-20->'OR'} を生成します。

SELECT {
  '-10': 'CA',
  '-20': 'OR'
}::MAP(
  NUMBER,
  VARCHAR
)

詳細については、 半構造化 OBJECTs と VARIANTs の MAPs へのキャスト をご参照ください。

構造化 OBJECT からのキーのリストの取得¶

構造化 OBJECT のキーのリストを取得するには、 OBJECT_KEYS 関数を呼び出します。

SELECT OBJECT_KEYS({'city':'San Mateo','state':'CA'}::OBJECT(city VARCHAR, state VARCHAR));

入力値が構造化 OBJECT の場合、この関数はキーを含む ARRAY(VARCHAR) を返します。入力値が半構造化 OBJECT の場合、この関数は ARRAY を返します。

MAP からのキーのリストの取得¶

MAP 内のキーのリストを取得するには、 MAP_KEYS 関数を呼び出します。

SELECT MAP_KEYS({'my_key':'my_value'}::MAP(VARCHAR,VARCHAR));

構造化型からの値と要素へのアクセス¶

次のメソッドを使用して、構造化 ARRAYs、構造化 OBJECTs、MAPs の値や要素にアクセスできます。

• GET 関数

• GET_IGNORE_CASE 関数

• GET_PATH 関数

• ドット表記

• かっこ表記

返される値や要素は VARIANT ではなく、オブジェクトに指定された型です。

次の例では、半構造化 ARRAY の最初の要素と ARRAY(VARCHAR) を SYSTEM$TYPEOF 関数に渡して、その要素のデータ型を返しています。

SELECT
  SYSTEM$TYPEOF(
    ARRAY_CONSTRUCT('San Mateo')[0]
  ) AS semi_structured_array_element,
  SYSTEM$TYPEOF(
    CAST(
      ARRAY_CONSTRUCT('San Mateo') AS ARRAY(VARCHAR)
    )[0]
  ) AS structured_array_element;

+-------------------------------+-----------------------------+
| SEMI_STRUCTURED_ARRAY_ELEMENT | STRUCTURED_ARRAY_ELEMENT    |
|-------------------------------+-----------------------------|
| VARIANT[LOB]                  | VARCHAR(16777216)[LOB]      |
+-------------------------------+-----------------------------+

次の点に注意してください。

• 構造化 OBJECT を GET または GET_IGNORE_CASE 関数に渡す場合、キーに定数を指定する必要があります。

  GET 関数に MAP または構造化 ARRAY を渡す場合は、定数を指定する必要はありません。

  また、 MAP を GET_IGNORE_CASE 関数に渡す場合は、定数を指定する必要はありません。

• 構造化 OBJECT、構造化 ARRAY、または MAP を GET_PATH 関数に渡す場合、パス名に定数を指定する必要があります。

• 構造化オブジェクトの場合、 OBJECT キーまたは存在しないパスを使用すると、コンパイル時にエラーが発生します。

  これに対して、半構造化オブジェクトに存在しないインデックス、キー、パスを使用すると、関数は NULL を返します。

構造化 ARRAY サイズの決定¶

構造化 ARRAY サイズを決定するには、 ARRAY を ARRAY_SIZE 関数に渡します。

SELECT ARRAY_SIZE([1,2,3]::ARRAY(NUMBER));

MAP サイズの決定¶

MAP のサイズを決定するには、 MAP を MAP_SIZE 関数に渡します。

SELECT MAP_SIZE({'my_key':'my_value'}::MAP(VARCHAR,VARCHAR));

構造化 ARRAY 内の要素の検索¶

ある要素が構造化 ARRAY に存在するかどうかを判断するには、 ARRAY_CONTAINS 関数を呼び出します。例:

SELECT ARRAY_CONTAINS(10, [1, 10, 100]::ARRAY(NUMBER));

構造化 ARRAY 内の要素の位置を決定するには、 ARRAY_POSITION 関数を呼び出します。例:

SELECT ARRAY_POSITION(10, [1, 10, 100]::ARRAY(NUMBER));

MAP がキーを含むかどうかの判断¶

MAP にキーが含まれているかどうかを判断するには、 MAP_CONTAINS_KEY 関数を呼び出します。

例:

SELECT MAP_CONTAINS_KEY('key_to_find', my_map);

SELECT MAP_CONTAINS_KEY(10, my_map);

構造化オブジェクトと半構造化オブジェクトの比較¶

構造化 ARRAY、構造化 OBJECT、または MAP を、半構造化 ARRAY、 OBJECT、または VARIANT と比較することはできません。

構造化オブジェクトと他の構造化オブジェクトの比較¶

同じ型の2つのオブジェクト（例えば、2つの構造化 ARRAYs、2つの構造化 OBJECTs、2つの MAPs）を比較することができます。

現在、構造化型を比較するために、次の比較演算子がサポートされています。

• =

• !=

• <

• <=

• >=

• >

2つの構造化オブジェクトを等しいかどうか比較する場合、次の点に注意してください。

• 一方の型をもう一方の型に 強制 できない場合、比較は失敗します。

• 数値キーを持つ MAPs を比較する場合、キーは数値として比較されます（VARCHAR の値としては比較されません）。

<、 <=、 >=、または > を使用して2つの構造化オブジェクトを比較する場合、構造化オブジェクトフィールドはアルファベット順に比較されます。例えば、次のオブジェクトは:

{'a':2,'b':1}::OBJECT(b INTEGER,a INTEGER)

次よりも大きいです:

{'a':1,'b':2}::OBJECT(b INTEGER,a INTEGER)

2つの ARRAYs が重複しているかどうかの判定¶

2つの構造化 ARRAYs の要素が重複しているかどうかを判断する必要がある場合は、 ARRAYS_OVERLAP 関数を呼び出します。例:

SELECT ARRAYS_OVERLAP(numeric_array, other_numeric_array);

ARRAYs は 比較可能な型 である必要があります。

この関数に半構造化 ARRAY と構造化 ARRAY を渡すことはできないことに注意してください。どちらの ARRAYs も構造化または半構造化のいずれかである必要があります。

半構造化 ARRAYs の変換¶

これらの関数に構造化 ARRAY を渡すと、関数は同じ型の構造化 ARRAY を返します。

• ARRAY_APPEND

• ARRAY_CAT

• ARRAY_COMPACT

• ARRAY_EXCEPT

• ARRAY_INSERT

• ARRAY_INTERSECTION

• ARRAY_PREPEND

• ARRAY_SLICE

• ARRAY_UNION_AGG

次のセクションでは、これらの関数が構造化 ARRAYs でどのように機能するかを説明します。

• 配列に要素を追加する関数

• 入力として複数の ARRAYs を受け付ける関数

SELECT ARRAY_APPEND( [1,2]::ARRAY(DOUBLE), 3::NUMBER );

SELECT ARRAY_APPEND( [1,2]::ARRAY(DOUBLE), '3' );

SELECT ARRAY_APPEND( [1,2]::ARRAY(NUMBER), '2022-02-02'::DATE );

SELECT ARRAY_CAT( [1,2]::ARRAY(NUMBER), ['3','4'] );

SELECT ARRAY_CAT( [1,2], ['3','4']::ARRAY(VARCHAR) );

SELECT
  ARRAY_CAT(
    [1, 2, 3]::ARRAY(NUMBER NOT NULL),
    [5.5, NULL]::ARRAY(NUMBER(2, 1))
  ) AS concatenated_array,
  SYSTEM$TYPEOF(concatenated_array);

+--------------------+-----------------------------------+
| CONCATENATED_ARRAY | SYSTEM$TYPEOF(CONCATENATED_ARRAY) |
|--------------------+-----------------------------------|
| [                  | ARRAY(NUMBER(38,1))[LOB]          |
|   1,               |                                   |
|   2,               |                                   |
|   3,               |                                   |
|   5.5,             |                                   |
|   undefined        |                                   |
| ]                  |                                   |
+--------------------+-----------------------------------+

SELECT ARRAY_EXCEPT( [1,2]::ARRAY(NUMBER), [2,3]::ARRAY(DOUBLE) );

SELECT ARRAY_EXCEPT( [1,2]::ARRAY(NUMBER), ['2','3']::ARRAY(VARCHAR) );

半構造化 OBJECTs の変換¶

以下のセクションでは、別の OBJECT から変換された構造化 OBJECT を返す方法を説明します。

• キーと値のペアの削除

• キーと値のペアの挿入と値の更新

• 既存の OBJECT からのキーと値のペアの選択

キーと値のペアの順序を変更したり、キーの名前を変更したり、値を指定せずにキーを追加したりする必要がある場合は、 CAST 関数または::演算子 を使用します。詳細については、 ある構造化型から別の構造型へのキャスト をご参照ください。

MAPs の変換¶

MAPs を変換するには、次の関数を使用します。

• MAP_CAT

• MAP_DELETE

• MAP_INSERT

• MAP_PICK

構造化型での FLATTEN 関数の使用¶

構造化 ARRAYs、構造化 OBJECTs、 MAPs を FLATTEN 関数に渡すことができます。半構造化データ型の場合と同様に、PATH 引数を使用してフラット化される値を指定することができます。

• フラット化される値が構造化 ARRAY で RECURSIVE 引数が FALSE の場合、 value 列には ARRAY と同じ型の値が含まれます。

  例:

  SELECT value, SYSTEM$TYPEOF(value)
    FROM TABLE(FLATTEN(INPUT => [1.08, 2.13, 3.14]::ARRAY(DOUBLE)));
  

  Copy

  +-------+----------------------+
  | VALUE | SYSTEM$TYPEOF(VALUE) |
  |-------+----------------------|
  |  1.08 | FLOAT[DOUBLE]        |
  |  2.13 | FLOAT[DOUBLE]        |
  |  3.14 | FLOAT[DOUBLE]        |
  +-------+----------------------+
  

• フラット化される値が MAP で、 RECURSIVE 引数が FALSE の場合、 key 列には MAP キーと同じ型のキーが含まれ、 value 列には MAP 値と同じ型の値が含まれます。

  例:

  SELECT key, SYSTEM$TYPEOF(key), value, SYSTEM$TYPEOF(value)
    FROM TABLE(FLATTEN(INPUT => {'my_key': 'my_value'}::MAP(VARCHAR, VARCHAR)));
  

  Copy

  +--------+------------------------+----------+------------------------+
  | KEY    | SYSTEM$TYPEOF(KEY)     | VALUE    | SYSTEM$TYPEOF(VALUE)   |
  |--------+------------------------+----------+------------------------|
  | my_key | VARCHAR(16777216)[LOB] | my_value | VARCHAR(16777216)[LOB] |
  +--------+------------------------+----------+------------------------+
  

• それ以外の場合、 key と value の列は VARIANT 型になります。

MAPs の場合、返されるキーと値の順序は不確定です。

PARSE_JSON 関数の使用¶

PARSE_JSON 関数は構造化型を返さないことに注意してください。

集合演算子と CASE 式での構造化型の使用¶

構造化 ARRAYs、構造化 OBJECTs、MAPs は次で使用することができます。

• 集合演算子（例: UNION ALL）によって組み合わされたクエリ式。

• CASE 式。

集合演算子の場合、異なる型が異なる式で使用されている場合（例えば、一方の型が ARRAY(NUMBER) で、もう一方が ARRAY(DOUBLE) の場合）、一方の型はもう一方の型に 強制 されます。

他の半構造化関数の操作¶

次の関数は、構造化 ARRAY、構造化 OBJECT、または MAP を入力引数として受け付けません。

• AS_ARRAY

• AS_OBJECT

• IS_ARRAY

• IS_OBJECT

• TYPEOF

構造化型を入力として渡すとエラーになります。

SHOW COLUMNS コマンドを使用した構造化型情報の表示¶

SHOW COLUMNS コマンドの出力では、 data_type 列に要素、キー、値の型に関する情報が含まれます。

DESCRIBE とその他の SHOW コマンドを使用した構造化型情報の表示¶

次のコマンドの出力には、構造化型に関する情報が含まれます。

• DESCRIBE TABLE

• DESCRIBE RESULT

• DESCRIBE FUNCTION

• DESCRIBE PROCEDURE

• SHOW FUNCTIONS

• SHOW PROCEDURES

例えば、 DESCRIBE RESULT 出力では、 MAP(VARCHAR, VARCHAR) 列の行には type 列に次の値が含まれます。

map(VARCHAR(16777216), VARCHAR(16777216))

ARRAY(NUMBER) 列の行には、 type 列に次の値が含まれます。

ARRAY(NUMBER(38,0))

データベースで使用される構造化型に関する情報の表示¶

構造化型の列の場合、 INFORMATION_SCHEMA COLUMNS ビュー は列の基本データ型（ARRAY、 OBJECT、または MAP）に関する情報のみを提供します。

例えば、 data_type 列には「ARRAY」、「OBJECT」、または「MAP」のみが含まれます。列には、要素、キー、値の型は含まれません。

要素、キー、値の型に関する情報を表示するには、次のビューを使用します。

• 構造化 ARRAYs の要素の型に関する情報については、 INFORMATION_SCHEMA の ELEMENT_TYPES ビュー または ACCOUNT_USAGE の ELEMENT_TYPES ビュー にクエリを実行します。

• 構造化 OBJECTs と MAPs のキーと値の型に関する情報については、 INFORMATION_SCHEMA の FIELDS ビュー または ACCOUNT_USAGE の FIELDS ビュー にクエリを実行します。