構造化データ型¶

構造化 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 型のキーを指定します。

  • OBJECT 定義の各 key は一意にする必要があります。

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

  • キーを指定せずに括弧を指定した場合（つまり 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) NOT NULL, num NUMBER(38,0))[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 にできないことを指定します。

次の例では、半構造化 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 関数を呼び出すか、:: 演算子 を使用します。

以下の半構造化型の値のみを、対応する構造化型の値にキャストします。そうしないと、ランタイムのエラーが発生します。

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

• 半構造化 ARRAY および VARIANT 値の構造化 ARRAY 値へのキャスト

• 半構造化 OBJECT および VARIANT 値の構造化 OBJECT 値へのキャスト

• 半構造化 OBJECT および VARIANT 値の MAP 値へのキャスト

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)値に強制できない。

  • ある型定義の OBJECT 値を、別の型定義の OBJECT 値に強制することができるのは、次のすべてが真である場合に限られます。

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

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

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

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

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

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

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

        • 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 値にキャストできます。

• MAP 値の場合、

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

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

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

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

+------------+
| CAST_ARRAY |
|------------|
| [          |
|   "1",     |
|   "2",     |
|   "3"      |
| ]          |
+------------+

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

+-----------------------+
| OBJECT_VALUE_ORDER    |
|-----------------------|
| {                     |
|   "state": "CA",      |
|   "city": "San Mateo" |
| }                     |
+-----------------------+

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

+-----------------------------+
| OBJECT_VALUE_KEY_NAMES      |
|-----------------------------|
| {                           |
|   "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) AS add_fields;

+------------------------+
| ADD_FIELDS             |
|------------------------|
| {                      |
|   "city": "San Mateo", |
|   "state": "CA",       |
|   "zipcode": null      |
| }                      |
+------------------------+

SQL 関数を使用した構造化 ARRAY と OBJECT 値の構築¶

以下の関数は、半構造化 ARRAY 値を構築します。

• ARRAY_CONSTRUCT

• ARRAY_CONSTRUCT_COMPACT

• ARRAY_AGG

• TO_ARRAY

以下の関数は、半構造化 OBJECT 値を構築します。

• OBJECT_CONSTRUCT

• OBJECT_CONSTRUCT_KEEP_NULL

• OBJECT_AGG

• TO_OBJECT

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

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

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

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

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

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

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

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

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

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

MAP 値の構築¶

MAP 値を構築するには、半構造化 OBJECT 値を構築し、 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
);

詳細については、 半構造化 OBJECT および VARIANT 値の MAP 値へのキャスト をご参照ください。

構造化 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));

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

次のメソッドを使用して、構造化 ARRAY、構造化 OBJECT、 MAP 値から値や要素にアクセスできます。

• 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 値を渡す場合は、定数を指定する必要はありません。

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

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

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

  対照的に、存在しないインデックス、キー、パスを半構造化 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つの構造化 ARRAY 値、2つの構造化 OBJECT 値、または2つの MAP 値）。

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

• =

• !=

• <

• <=

• >=

• >

2つの構造化値が等しいかどうか比較する場合は、以下の点に注意してください。

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

• 数値キーを持つ MAP 値を比較する場合、キーは（VARCHAR 値としてではなく）数値として比較されます。

<、 <=、 >=、 > を使用して2つの構造化値を比較する場合、構造化値フィールドはアルファベット順に比較されます。たとえば、以下の値は、

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

次よりも大きいです:

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

2つの ARRAY 値が重なるかどうかの判定¶

2つの構造化 ARRAY 値の要素が重なっているかどうかを判断するには、 ARRAYS_OVERLAP 関数を呼び出します。例:

SELECT ARRAYS_OVERLAP(numeric_array, other_numeric_array);

ARRAY 値は、 比較可能な型 にする必要があります。

この関数に半構造化 ARRAY 値と構造化 ARRAY 値を渡すことはできません。ARRAY 値の両方とも構造化にするか、半構造化にする必要があります。

構造化 ARRAY 値の変換¶

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

• ARRAY_APPEND

• ARRAY_CAT

• ARRAY_COMPACT

• ARRAY_EXCEPT

• ARRAY_INSERT

• ARRAY_INTERSECTION

• ARRAY_PREPEND

• ARRAY_SLICE

• ARRAY_UNION_AGG

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

• ARRAY 値に要素を追加する関数

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

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

構造化 OBJECT 値の変換¶

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

• キーと値のペアの削除

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

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

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

MAP 値の変換¶

MAP 値を変換するには、以下の関数を使用します。

• MAP_CAT

• MAP_DELETE

• MAP_INSERT

• MAP_PICK

構造化型の値をともなう FLATTEN 関数の使用¶

構造化 ARRAY、構造化 OBJECT、 MAP 値を 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 型になります。

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

PARSE_JSON 関数の使用¶

PARSE_JSON 関数は構造化型を返しません。

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

構造化 ARRAY、構造化 OBJECT、 MAP 値は次で使用することができます。

• 集合演算子（例: 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 のみが含まれます。列には、要素、キー、値の型は含まれません。

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

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

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