카테고리:

변환 함수 , 반정형 데이터 함수 (캐스트)

TO_JSON

VARIANT 값을 값의 JSON 표현이 포함된 문자열로 변환합니다. 입력이 NULL이면 결과도 NULL입니다.

구문

TO_JSON( <expr> )

인자

expr

유효한 JSON 정보를 보유하는 VARIANT 형식의 식입니다.

반환

반환된 값은 VARCHAR 형식입니다.

사용법 노트

  • 입력이 NULL이면 출력도 NULL입니다. 입력이 JSON null 을 포함하는 VARIANT인 경우, 반환된 값은 문자열 '"null"' 입니다(즉, 큰따옴표로 묶인 단어 《null》). 아래의 예 섹션에 예가 포함되어 있습니다.

  • JSON 오브젝트(《사전》 또는 《해시》라고도 함)는 순서가 지정되지 않은 키-값 페어의 세트입니다. TO_JSON 이 문자열을 생성할 때 해당 문자열의 키-값 페어의 순서는 예측할 수 없습니다.

  • TO_JSONPARSE_JSON 은 (거의) 역 또는 상호 함수입니다.

    • PARSE_JSON 함수는 문자열을 입력값으로 받아 JSON 호환 VARIANT 를 반환합니다.

    • TO_JSON 함수는 JSON 호환 VARIANT를 받아 문자열을 반환합니다.

    X가 유효한 JSON을 포함하는 문자열인 경우, 다음은 (개념적으로) true입니다.

    X = TO_JSON(PARSE_JSON(X));

    예를 들어, 다음은 (개념적으로) true입니다.

    '{"pi":3.14,"e":2.71}' = TO_JSON(PARSE_JSON('{"pi":3.14,"e":2.71}'))

    그러나 다음과 같은 이유로 이 함수는 완벽하게 상호적이지는 않습니다.

    • 빈 문자열과 공백만 있는 문자열은 상호적으로 처리되지 않습니다. 예를 들어 PARSE_JSON('') 의 반환 값은 NULL이지만, TO_JSON(NULL) 의 반환 값은 '' 가 아닙니다.

    • TO_JSON 에 의해 생성된 문자열의 키-값 페어의 순서는 예측할 수 없습니다.

    • TO_JSON 에 의해 생성된 문자열은 PARSE_JSON 에 전달된 문자열보다 공백이 적을 수 있습니다.

    예를 들어 다음은 동등한 JSON이지만, 동등한 문자열은 아닙니다.

    • {"pi": 3.14, "e": 2.71}

    • {"e":2.71,"pi":3.14}

다음은 TO_JSONPARSE_JSON 의 간단한 예입니다.

CREATE TABLE jdemo1 (v VARIANT);
INSERT INTO jdemo1 SELECT PARSE_JSON('{"food":"bard"}');
SELECT v, v:food, TO_JSON(v) FROM jdemo1;
+------------------+--------+-----------------+
| V                | V:FOOD | TO_JSON(V)      |
|------------------+--------+-----------------|
| {                | "bard" | {"food":"bard"} |
|   "food": "bard" |        |                 |
| }                |        |                 |
+------------------+--------+-----------------+

다음 예는 PARSE_JSONTO_JSON 에 대한 NULL 처리를 보여줍니다.

SELECT TO_JSON(NULL), TO_JSON('null'::VARIANT),
       PARSE_JSON(NULL), PARSE_JSON('null');
+---------------+--------------------------+------------------+--------------------+
| TO_JSON(NULL) | TO_JSON('NULL'::VARIANT) | PARSE_JSON(NULL) | PARSE_JSON('NULL') |
|---------------+--------------------------+------------------+--------------------|
| NULL          | "null"                   | NULL             | null               |
+---------------+--------------------------+------------------+--------------------+

다음 예는 PARSE_JSON, TO_JSON, TO_VARIANT 간의 관계를 보여줍니다.

테이블을 만들고 VARCHAR 일반 VARIANT, JSON 호환 VARIANT 데이터를 추가합니다. INSERT 문은 VARCHAR 값을 삽입하고, UPDATE 문은 그 VARCHAR에 해당하는 JSON 값을 생성합니다.

CREATE or replace TABLE jdemo2 (varchar1 VARCHAR, variant1 VARIANT,
    variant2 VARIANT);
INSERT INTO jdemo2 (varchar1) VALUES ('{"PI":3.14}');
UPDATE jdemo2 SET variant1 = PARSE_JSON(varchar1);

이 쿼리는 TO_JSONPARSE_JSON 이 개념적으로 상호 함수임을 보여줍니다.

SELECT varchar1, PARSE_JSON(varchar1), variant1,  TO_JSON(variant1),
                 PARSE_JSON(varchar1) = variant1, TO_JSON(variant1) = varchar1
    FROM jdemo2;
+-------------+----------------------+--------------+-------------------+---------------------------------+------------------------------+
| VARCHAR1    | PARSE_JSON(VARCHAR1) | VARIANT1     | TO_JSON(VARIANT1) | PARSE_JSON(VARCHAR1) = VARIANT1 | TO_JSON(VARIANT1) = VARCHAR1 |
|-------------+----------------------+--------------+-------------------+---------------------------------+------------------------------|
| {"PI":3.14} | {                    | {            | {"PI":3.14}       | True                            | True                         |
|             |   "PI": 3.14         |   "PI": 3.14 |                   |                                 |                              |
|             | }                    | }            |                   |                                 |                              |
+-------------+----------------------+--------------+-------------------+---------------------------------+------------------------------+

그러나 이 함수는 정확히 상호적이지는 않습니다. 공백 또는 키-값 페어의 순서 차이로 인해 출력이 입력과 일치하지 않을 수 있습니다. 예:

SELECT
    TO_JSON(PARSE_JSON('{"b":1,"a":2}')),
    TO_JSON(PARSE_JSON('{"b":1,"a":2}')) = '{"b":1,"a":2}',
    TO_JSON(PARSE_JSON('{"b":1,"a":2}')) = '{"a":2,"b":1}'
    ;
+--------------------------------------+--------------------------------------------------------+--------------------------------------------------------+
| TO_JSON(PARSE_JSON('{"B":1,"A":2}')) | TO_JSON(PARSE_JSON('{"B":1,"A":2}')) = '{"B":1,"A":2}' | TO_JSON(PARSE_JSON('{"B":1,"A":2}')) = '{"A":2,"B":1}' |
|--------------------------------------+--------------------------------------------------------+--------------------------------------------------------|
| {"a":2,"b":1}                        | False                                                  | True                                                   |
+--------------------------------------+--------------------------------------------------------+--------------------------------------------------------+

PARSE_JSONTO_VARIANT 모두 문자열을 사용하여 베리언트를 반환할 수 있지만, 동등하지는 않습니다. 다음 코드는 PARSE_JSON 을 사용하여 한 열을 업데이트하고 TO_VARIANT 를 사용하여 다른 열을 업데이트합니다. (열 variant1 에 대한 업데이트는 동일한 함수 호출을 사용하여 이전에 업데이트되었기 때문에 필요하지 않습니다. 그러나 아래 코드는 열을 업데이트하기 위해 호출되는 함수를 나란히 볼 수 있도록 다시 업데이트합니다.)

UPDATE jdemo2 SET
    variant1 = PARSE_JSON(varchar1),
    variant2 = TO_VARIANT(varchar1);

아래 쿼리는 PARSE_JSON 의 출력과 TO_VARIANT 의 출력이 동일하지 않음을 보여줍니다. 공백의 사소한 차이 외에, 따옴표에도 상당한 차이가 있습니다.

SELECT variant1, variant2, variant1 = variant2 FROM jdemo2;
+--------------+-----------------+---------------------+
| VARIANT1     | VARIANT2        | VARIANT1 = VARIANT2 |
|--------------+-----------------+---------------------|
| {            | "{\"PI\":3.14}" | False               |
|   "PI": 3.14 |                 |                     |
| }            |                 |                     |
+--------------+-----------------+---------------------+
맨 위로 이동