14.17.4 Functions That Modify JSON Values

14.17.4 Functions That Modify JSON Values

이 절의 함수들은 JSON 값을 수정하고 그 결과를 반환합니다.

• JSON_ARRAY_APPEND(json_doc, path, val[, path, val] ...)

지정된 JSON 도큐먼트 안의 배열 끝에 값을 append 하고 그 결과를 반환합니다. 어떤 인수라도 NULL이면 NULL을 반환합니다. json_doc 인수가 유효한 JSON 도큐먼트가 아니거나, 어느 path 인수라도 유효한 패스 식이 아니거나 * 또는 ** 와일드카드를 포함하면 에러가 발생합니다.

path-value 쌍은 왼쪽에서 오른쪽 순으로 평가됩니다. 하나의 쌍을 평가하여 생성된 도큐먼트가 다음 쌍이 평가될 때 기준이 되는 새로운 값이 됩니다.

어떤 패스가 스칼라 또는 오브젝트 값을 선택하면, 그 값은 배열로 자동 래핑되고 새로운 값이 그 배열에 추가됩니다. 패스가 JSON 도큐먼트 안에서 어떤 값도 식별하지 못하는 쌍은 무시됩니다.

1mysql> SET @j = '["a", ["b", "c"], "d"]';
2mysql> SELECT JSON_ARRAY_APPEND(@j, '$[1]', 1);
3+----------------------------------+
4| JSON_ARRAY_APPEND(@j, '$[1]', 1) |
5+----------------------------------+
6| ["a", ["b", "c", 1], "d"]        |
7+----------------------------------+
8mysql> SELECT JSON_ARRAY_APPEND(@j, '$[0]', 2);
9+----------------------------------+
10| JSON_ARRAY_APPEND(@j, '$[0]', 2) |
11+----------------------------------+
12| [["a", 2], ["b", "c"], "d"]      |
13+----------------------------------+
14mysql> SELECT JSON_ARRAY_APPEND(@j, '$[1][0]', 3);
15+-------------------------------------+
16| JSON_ARRAY_APPEND(@j, '$[1][0]', 3) |
17+-------------------------------------+
18| ["a", [["b", 3], "c"], "d"]         |
19+-------------------------------------+
20
21mysql> SET @j = '{"a": 1, "b": [2, 3], "c": 4}';
22mysql> SELECT JSON_ARRAY_APPEND(@j, '$.b', 'x');
23+------------------------------------+
24| JSON_ARRAY_APPEND(@j, '$.b', 'x')  |
25+------------------------------------+
26| {"a": 1, "b": [2, 3, "x"], "c": 4} |
27+------------------------------------+
28mysql> SELECT JSON_ARRAY_APPEND(@j, '$.c', 'y');
29+--------------------------------------+
30| JSON_ARRAY_APPEND(@j, '$.c', 'y')    |
31+--------------------------------------+
32| {"a": 1, "b": [2, 3], "c": [4, "y"]} |
33+--------------------------------------+
34
35mysql> SET @j = '{"a": 1}';
36mysql> SELECT JSON_ARRAY_APPEND(@j, '$', 'z');
37+---------------------------------+
38| JSON_ARRAY_APPEND(@j, '$', 'z') |
39+---------------------------------+
40| [{"a": 1}, "z"]                 |
41+---------------------------------+

• JSON_ARRAY_INSERT(json_doc, path, val[, path, val] ...)

JSON 도큐먼트를 갱신하면서, 도큐먼트 안의 배열에 값을 insert 하고 변경된 도큐먼트를 반환합니다. 어떤 인수라도 NULL이면 NULL을 반환합니다. json_doc 인수가 유효한 JSON 도큐먼트가 아니거나, 어느 path 인수라도 유효한 패스 식이 아니거나 * 또는 ** 와일드카드를 포함하거나 배열 요소 식별자로 끝나지 않으면 에러가 발생합니다.

path-value 쌍은 왼쪽에서 오른쪽 순으로 평가됩니다. 하나의 쌍을 평가하여 생성된 도큐먼트가 다음 쌍이 평가될 때 기준이 되는 새로운 값이 됩니다.

패스가 JSON 도큐먼트 안에서 어떤 배열도 식별하지 못하는 쌍은 무시됩니다. 패스가 배열 요소를 식별하면, 해당 위치에 값을 insert 하고 뒤따르는 값들은 오른쪽으로 이동합니다. 패스가 배열 끝을 넘어서는 배열 위치를 식별하면, 값은 배열 끝에 insert 됩니다.

1mysql> SET @j = '["a", {"b": [1, 2]}, [3, 4]]';
2mysql> SELECT JSON_ARRAY_INSERT(@j, '$[1]', 'x');
3+------------------------------------+
4| JSON_ARRAY_INSERT(@j, '$[1]', 'x') |
5+------------------------------------+
6| ["a", "x", {"b": [1, 2]}, [3, 4]]  |
7+------------------------------------+
8mysql> SELECT JSON_ARRAY_INSERT(@j, '$[100]', 'x');
9+--------------------------------------+
10| JSON_ARRAY_INSERT(@j, '$[100]', 'x') |
11+--------------------------------------+
12| ["a", {"b": [1, 2]}, [3, 4], "x"]    |
13+--------------------------------------+
14mysql> SELECT JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x');
15+-----------------------------------------+
16| JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x') |
17+-----------------------------------------+
18| ["a", {"b": ["x", 1, 2]}, [3, 4]]       |
19+-----------------------------------------+
20mysql> SELECT JSON_ARRAY_INSERT(@j, '$[2][1]', 'y');
21+---------------------------------------+
22| JSON_ARRAY_INSERT(@j, '$[2][1]', 'y') |
23+---------------------------------------+
24| ["a", {"b": [1, 2]}, [3, "y", 4]]     |
25+---------------------------------------+
26mysql> SELECT JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y');
27+----------------------------------------------------+
28| JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y') |
29+----------------------------------------------------+
30| ["x", "a", {"b": [1, 2]}, [3, 4]]                  |
31+----------------------------------------------------+

이전에 수행된 수정 작업은 배열 안의 이후 요소들의 위치에 영향을 주므로, 같은 JSON_ARRAY_INSERT() 호출에서 뒤따르는 패스들은 이를 고려해야 합니다. 마지막 예에서 두 번째 패스는, 첫 번째 insert 이후에는 패스가 더 이상 어떤 것도 일치시키지 못하므로 아무 것도 insert 하지 않습니다.

• JSON_INSERT(json_doc, path, val[, path, val] ...)

JSON 도큐먼트에 데이터를 insert 하고 그 결과를 반환합니다. 어떤 인수라도 NULL이면 NULL을 반환합니다. json_doc 인수가 유효한 JSON 도큐먼트가 아니거나, 어느 path 인수라도 유효한 패스 식이 아니거나 * 또는 ** 와일드카드를 포함하면 에러가 발생합니다.

path-value 쌍은 왼쪽에서 오른쪽 순으로 평가됩니다. 하나의 쌍을 평가하여 생성된 도큐먼트가 다음 쌍이 평가될 때 기준이 되는 새로운 값이 됩니다.

도큐먼트 안에서 이미 존재하는 패스에 대한 path-value 쌍은 무시되며 기존 도큐먼트 값을 overwrite 하지 않습니다. 도큐먼트 안에서 존재하지 않는 패스에 대한 path-value 쌍은, 패스가 다음과 같은 유형의 값을 식별하면 그 값을 도큐먼트에 추가합니다:

• 기존 오브젝트에 존재하지 않는 멤버. 이 멤버는 오브젝트에 추가되고 새로운 값과 연관됩니다.

• 기존 배열의 끝을 넘는 위치. 배열은 새 값으로 확장됩니다. 기존 값이 배열이 아니면, 배열로 자동 래핑된 다음 새 값으로 확장됩니다.

그렇지 않으면, 도큐먼트 안에서 존재하지 않는 패스에 대한 path-value 쌍은 무시되며 아무 영향도 주지 않습니다.

JSON_INSERT(), JSON_REPLACE(), JSON_SET()을 비교하려면 JSON_SET()에 대한 설명을 참조하십시오.

1mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
2mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]');
3+----------------------------------------------------+
4| JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]') |
5+----------------------------------------------------+
6| {"a": 1, "b": [2, 3], "c": "[true, false]"}        |
7+----------------------------------------------------+

결과에 나열된 세 번째이자 마지막 값은, output 에서 따옴표로 둘러싸이지 않은 두 번째 값(배열)과 달리 따옴표로 둘러싸인 문자열이며 배열이 아닙니다. 값들을 JSON 타입으로 캐스팅하는 작업은 수행되지 않습니다. 배열을 배열로 insert 하려면, 다음과 같이 명시적으로 캐스팅을 수행해야 합니다:

1mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', CAST('[true, false]' AS JSON));
2+------------------------------------------------------------------+
3| JSON_INSERT(@j, '$.a', 10, '$.c', CAST('[true, false]' AS JSON)) |
4+------------------------------------------------------------------+
5| {"a": 1, "b": [2, 3], "c": [true, false]}                        |
6+------------------------------------------------------------------+
71 row in set (0.00 sec)

• JSON_MERGE(json_doc, json_doc[, json_doc] ...)

JSON_MERGE_PRESERVE()의 폐기 예정 시노님입니다.

• JSON_MERGE_PATCH(json_doc, json_doc[, json_doc] ...)

두 개 이상의 JSON 도큐먼트를 RFC 7396을 준수하여 merge 하고, 중복 키를 가진 멤버들을 preserve 하지 않은 채 merge 된 결과를 반환합니다. 이 함수에 인수로 전달되는 도큐먼트 중 하나라도 유효하지 않으면 에러를 발생시킵니다.

참고

이 함수와 JSON_MERGE_PRESERVE()의 차이에 대한 설명과 예는 JSON_MERGE_PATCH() compared with JSON_MERGE_PRESERVE()를 참조하십시오.

JSON_MERGE_PATCH()는 다음과 같이 merge 를 수행합니다:

1. 첫 번째 인수가 오브젝트가 아니면, merge 결과는 빈 오브젝트가 두 번째 인수와 merge 된 것과 동일합니다.

2. 두 번째 인수가 오브젝트가 아니면, merge 결과는 두 번째 인수입니다.

3. 두 인수 모두 오브젝트이면, merge 결과는 다음 멤버들을 가진 오브젝트입니다:

   • 두 번째 오브젝트 안에 같은 키를 가진 대응 멤버가 존재하지 않는, 첫 번째 오브젝트의 모든 멤버.

   • 첫 번째 오브젝트에 대응 키가 존재하지 않고, 값이 JSON null 리터럴이 아닌, 두 번째 오브젝트의 모든 멤버.

   • 첫 번째 오브젝트와 두 번째 오브젝트 모두에 존재하는 키를 가진 모든 멤버 중에서, 두 번째 오브젝트에 있는 값이 JSON null 리터럴이 아닌 멤버. 이 멤버들의 값은, 첫 번째 오브젝트의 값과 두 번째 오브젝트의 값을 재귀적으로 merge 한 결과입니다.

추가 정보는 Normalization, Merging, and Autowrapping of JSON Values를 참조하십시오.

1mysql> SELECT JSON_MERGE_PATCH('[1, 2]', '[true, false]');
2+---------------------------------------------+
3| JSON_MERGE_PATCH('[1, 2]', '[true, false]') |
4+---------------------------------------------+
5| [true, false]                               |
6+---------------------------------------------+
7
8mysql> SELECT JSON_MERGE_PATCH('{"name": "x"}', '{"id": 47}');
9+-------------------------------------------------+
10| JSON_MERGE_PATCH('{"name": "x"}', '{"id": 47}') |
11+-------------------------------------------------+
12| {"id": 47, "name": "x"}                         |
13+-------------------------------------------------+
14
15mysql> SELECT JSON_MERGE_PATCH('1', 'true');
16+-------------------------------+
17| JSON_MERGE_PATCH('1', 'true') |
18+-------------------------------+
19| true                          |
20+-------------------------------+
21
22mysql> SELECT JSON_MERGE_PATCH('[1, 2]', '{"id": 47}');
23+------------------------------------------+
24| JSON_MERGE_PATCH('[1, 2]', '{"id": 47}') |
25+------------------------------------------+
26| {"id": 47}                               |
27+------------------------------------------+
28
29mysql> SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }',
30     >     '{ "a": 3, "c":4 }');
31+-----------------------------------------------------------+
32| JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }') |
33+-----------------------------------------------------------+
34| {"a": 3, "b": 2, "c": 4}                                  |
35+-----------------------------------------------------------+
36
37mysql> SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }',
38     >     '{ "a": 5, "d":6 }');
39+-------------------------------------------------------------------------------+
40| JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }','{ "a": 5, "d":6 }') |
41+-------------------------------------------------------------------------------+
42| {"a": 5, "b": 2, "c": 4, "d": 6}                                              |
43+-------------------------------------------------------------------------------+

이 함수는 두 번째 인수에서 같은 멤버의 값을 null로 지정함으로써 멤버를 제거하는 데 사용할 수 있습니다:

1mysql> SELECT JSON_MERGE_PATCH('{"a":1, "b":2}', '{"b":null}');
2+--------------------------------------------------+
3| JSON_MERGE_PATCH('{"a":1, "b":2}', '{"b":null}') |
4+--------------------------------------------------+
5| {"a": 1}                                         |
6+--------------------------------------------------+

다음 예는 이 함수가 재귀적 방식으로 동작함을 보여줍니다. 즉, 멤버의 값은 스칼라로 제한되지 않고, 자체가 JSON 도큐먼트가 될 수도 있습니다:

1mysql> SELECT JSON_MERGE_PATCH('{"a":{"x":1}}', '{"a":{"y":2}}');
2+----------------------------------------------------+
3| JSON_MERGE_PATCH('{"a":{"x":1}}', '{"a":{"y":2}}') |
4+----------------------------------------------------+
5| {"a": {"x": 1, "y": 2}}                            |
6+----------------------------------------------------+

JSON_MERGE_PATCH() compared with JSON_MERGE_PRESERVE().

JSON_MERGE_PATCH()의 동작은, 다음 두 가지 예외를 제외하면 JSON_MERGE_PRESERVE()의 동작과 동일합니다:

• JSON_MERGE_PATCH()는, 두 번째 오브젝트에서 키와 연관된 값이 JSON null이 아닌 경우, 첫 번째 오브젝트의 멤버 중에서 두 번째 오브젝트에 같은 키를 가진 멤버를 제거합니다.

• 두 번째 오브젝트에, 첫 번째 오브젝트의 멤버와 키가 일치하는 멤버가 있는 경우, JSON_MERGE_PATCH()는 첫 번째 오브젝트의 값을 두 번째 오브젝트의 값으로 _대체_하는 반면, JSON_MERGE_PRESERVE()는 두 번째 값을 첫 번째 값 뒤에 append 합니다.

다음 예는 "a"라는 동일한 키를 가진 3개의 JSON 오브젝트를 이 두 함수 각각으로 merge 했을 때의 결과를 비교합니다:

1mysql> SET @x = '{ "a": 1, "b": 2 }',
2     >     @y = '{ "a": 3, "c": 4 }',
3     >     @z = '{ "a": 5, "d": 6 }';
4
5mysql> SELECT  JSON_MERGE_PATCH(@x, @y, @z)    AS Patch,
6    ->         JSON_MERGE_PRESERVE(@x, @y, @z) AS Preserve\G
7*************************** 1. row ***************************
8   Patch: {"a": 5, "b": 2, "c": 4, "d": 6}
9Preserve: {"a": [1, 3, 5], "b": 2, "c": 4, "d": 6}

• JSON_MERGE_PRESERVE(json_doc, json_doc[, json_doc] ...)

두 개 이상의 JSON 도큐먼트를 merge 하고 merge 된 결과를 반환합니다. 어떤 인수라도 NULL이면 NULL을 반환합니다. 어떤 인수라도 유효한 JSON 도큐먼트가 아니면 에러가 발생합니다.

merge 는 다음 규칙에 따라 수행됩니다. 추가 정보는 Normalization, Merging, and Autowrapping of JSON Values를 참조하십시오.

• 인접한 배열들은 하나의 배열로 merge 됩니다.

• 인접한 오브젝트들은 하나의 오브젝트로 merge 됩니다.

• 스칼라 값은 배열로 자동 래핑되어 배열로서 merge 됩니다.

• 인접한 배열과 오브젝트는, 오브젝트를 배열로 자동 래핑한 다음 두 배열을 merge 함으로써 merge 됩니다.

1mysql> SELECT JSON_MERGE_PRESERVE('[1, 2]', '[true, false]');
2+------------------------------------------------+
3| JSON_MERGE_PRESERVE('[1, 2]', '[true, false]') |
4+------------------------------------------------+
5| [1, 2, true, false]                            |
6+------------------------------------------------+
7
8mysql> SELECT JSON_MERGE_PRESERVE('{"name": "x"}', '{"id": 47}');
9+----------------------------------------------------+
10| JSON_MERGE_PRESERVE('{"name": "x"}', '{"id": 47}') |
11+----------------------------------------------------+
12| {"id": 47, "name": "x"}                            |
13+----------------------------------------------------+
14
15mysql> SELECT JSON_MERGE_PRESERVE('1', 'true');
16+----------------------------------+
17| JSON_MERGE_PRESERVE('1', 'true') |
18+----------------------------------+
19| [1, true]                        |
20+----------------------------------+
21
22mysql> SELECT JSON_MERGE_PRESERVE('[1, 2]', '{"id": 47}');
23+---------------------------------------------+
24| JSON_MERGE_PRESERVE('[1, 2]', '{"id": 47}') |
25+---------------------------------------------+
26| [1, 2, {"id": 47}]                          |
27+---------------------------------------------+
28
29mysql> SELECT JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }',
30     >    '{ "a": 3, "c": 4 }');
31+--------------------------------------------------------------+
32| JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c":4 }') |
33+--------------------------------------------------------------+
34| {"a": [1, 3], "b": 2, "c": 4}                                |
35+--------------------------------------------------------------+
36
37mysql> SELECT JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c": 4 }',
38     >    '{ "a": 5, "d": 6 }');
39+----------------------------------------------------------------------------------+
40| JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c": 4 }','{ "a": 5, "d": 6 }') |
41+----------------------------------------------------------------------------------+
42| {"a": [1, 3, 5], "b": 2, "c": 4, "d": 6}                                         |
43+----------------------------------------------------------------------------------+

이 함수는 JSON_MERGE_PATCH()와 유사하지만 중요한 측면에서 다릅니다. 자세한 내용은 JSON_MERGE_PATCH() compared with JSON_MERGE_PRESERVE()를 참조하십시오.

• JSON_REMOVE(json_doc, path[, path] ...)

JSON 도큐먼트에서 데이터를 제거하고 그 결과를 반환합니다. 어떤 인수라도 NULL이면 NULL을 반환합니다. json_doc 인수가 유효한 JSON 도큐먼트가 아니거나, 어느 path 인수라도 유효한 패스 식이 아니거나, $ 이거나 * 또는 ** 와일드카드를 포함하면 에러가 발생합니다.

path 인수들은 왼쪽에서 오른쪽 순으로 평가됩니다. 하나의 패스를 평가하여 생성된 도큐먼트가 다음 패스가 평가될 때 기준이 되는 새로운 값이 됩니다.

제거될 요소가 도큐먼트에 존재하지 않는다고 해도 에러는 아닙니다. 이 경우 해당 패스는 도큐먼트에 아무 영향도 주지 않습니다.

1mysql> SET @j = '["a", ["b", "c"], "d"]';
2mysql> SELECT JSON_REMOVE(@j, '$[1]');
3+-------------------------+
4| JSON_REMOVE(@j, '$[1]') |
5+-------------------------+
6| ["a", "d"]              |
7+-------------------------+

• JSON_REPLACE(json_doc, path, val[, path, val] ...)

JSON 도큐먼트에서 기존 값을 교체하고 그 결과를 반환합니다. json_doc 또는 어느 path 인수라도 NULL이면 NULL을 반환합니다. json_doc 인수가 유효한 JSON 도큐먼트가 아니거나, 어느 path 인수라도 유효한 패스 식이 아니거나 * 또는 ** 와일드카드를 포함하면 에러가 발생합니다.

path-value 쌍은 왼쪽에서 오른쪽 순으로 평가됩니다. 하나의 쌍을 평가하여 생성된 도큐먼트가 다음 쌍이 평가될 때 기준이 되는 새로운 값이 됩니다.

도큐먼트 안에서 이미 존재하는 패스에 대한 path-value 쌍은 기존 도큐먼트 값을 새로운 값으로 overwrite 합니다. 도큐먼트 안에서 존재하지 않는 패스에 대한 path-value 쌍은 무시되며 아무 영향도 주지 않습니다.

옵티마이저는, 컬럼의 기존 도큐먼트를 제거하고 전체 새로운 도큐먼트를 컬럼에 쓰는 대신 JSON 컬럼에 대해 부분적인 인플레이스 업데이트를 수행할 수 있습니다. 이 최적화는, JSON_REPLACE() 함수를 사용하는 업데이트 문장이 Partial Updates of JSON Values에 요약된 조건을 만족하는 경우에 수행될 수 있습니다.

JSON_INSERT(), JSON_REPLACE(), JSON_SET()을 비교하려면 JSON_SET()에 대한 설명을 참조하십시오.

1mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
2mysql> SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]');
3+-----------------------------------------------------+
4| JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]') |
5+-----------------------------------------------------+
6| {"a": 10, "b": [2, 3]}                              |
7+-----------------------------------------------------+
8
9mysql> SELECT JSON_REPLACE(NULL, '$.a', 10, '$.c', '[true, false]');
10+-------------------------------------------------------+
11| JSON_REPLACE(NULL, '$.a', 10, '$.c', '[true, false]') |
12+-------------------------------------------------------+
13| NULL                                                  |
14+-------------------------------------------------------+
15
16mysql> SELECT JSON_REPLACE(@j, NULL, 10, '$.c', '[true, false]');
17+----------------------------------------------------+
18| JSON_REPLACE(@j, NULL, 10, '$.c', '[true, false]') |
19+----------------------------------------------------+
20| NULL                                               |
21+----------------------------------------------------+
22
23mysql> SELECT JSON_REPLACE(@j, '$.a', NULL, '$.c', '[true, false]');
24+-------------------------------------------------------+
25| JSON_REPLACE(@j, '$.a', NULL, '$.c', '[true, false]') |
26+-------------------------------------------------------+
27| {"a": null, "b": [2, 3]}                              |
28+-------------------------------------------------------+

• JSON_SET(json_doc, path, val[, path, val] ...)

JSON 도큐먼트에 데이터를 insert 하거나 업데이트하고 결과를 반환합니다. json_doc 또는 path 가 NULL이거나, 주어진 path 가 오브젝트를 찾지 못하면 NULL을 반환합니다. 그 외의 경우, json_doc 인수가 유효한 JSON 도큐먼트가 아니거나, 어느 path 인수라도 유효한 패스 식이 아니거나 * 또는 ** 와일드카드를 포함하면 에러가 발생합니다.

path-value 쌍은 왼쪽에서 오른쪽 순으로 평가됩니다. 하나의 쌍을 평가하여 생성된 도큐먼트가 다음 쌍이 평가될 때 기준이 되는 새로운 값이 됩니다.

도큐먼트 안에서 이미 존재하는 패스에 대한 path-value 쌍은 기존 도큐먼트 값을 새로운 값으로 overwrite 합니다. 도큐먼트 안에서 존재하지 않는 패스에 대한 path-value 쌍은, 패스가 다음과 같은 유형의 값을 식별하는 경우 도큐먼트에 값을 추가합니다:

• 기존 오브젝트에 존재하지 않는 멤버. 이 멤버는 오브젝트에 추가되고 새로운 값과 연관됩니다.

• 기존 배열의 끝을 넘는 위치. 배열은 새 값으로 확장됩니다. 기존 값이 배열이 아니면, 배열로 자동 래핑된 다음 새 값으로 확장됩니다.

그렇지 않으면, 도큐먼트 안에서 존재하지 않는 패스에 대한 path-value 쌍은 무시되며 아무 영향도 주지 않습니다.

옵티마이저는, 컬럼의 기존 도큐먼트를 제거하고 전체 새로운 도큐먼트를 컬럼에 쓰는 대신 JSON 컬럼에 대해 부분적인 인플레이스 업데이트를 수행할 수 있습니다. 이 최적화는, JSON_SET() 함수를 사용하는 업데이트 문장이 Partial Updates of JSON Values에 요약된 조건을 만족하는 경우에 수행될 수 있습니다.

JSON_SET(), JSON_INSERT(), JSON_REPLACE() 함수들은 서로 관련이 있습니다:

• JSON_SET()는 기존 값을 교체하고 존재하지 않는 값을 추가합니다.

• JSON_INSERT()는 기존 값을 교체하지 않고 값을 insert 합니다.

• JSON_REPLACE()는 기존 값만 교체합니다.

다음 예는, 도큐먼트 안에 존재하는 패스 ($.a) 하나와 존재하지 않는 패스 ($.c) 하나를 사용하여 이 차이점을 설명합니다:

1mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
2mysql> SELECT JSON_SET(@j, '$.a', 10, '$.c', '[true, false]');
3+-------------------------------------------------+
4| JSON_SET(@j, '$.a', 10, '$.c', '[true, false]') |
5+-------------------------------------------------+
6| {"a": 10, "b": [2, 3], "c": "[true, false]"}    |
7+-------------------------------------------------+
8mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]');
9+----------------------------------------------------+
10| JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]') |
11+----------------------------------------------------+
12| {"a": 1, "b": [2, 3], "c": "[true, false]"}        |
13+----------------------------------------------------+
14mysql> SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]');
15+-----------------------------------------------------+
16| JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]') |
17+-----------------------------------------------------+
18| {"a": 10, "b": [2, 3]}                              |
19+-----------------------------------------------------+

• JSON_UNQUOTE(json_val)

JSON 값의 따옴표를 제거(unquote)하고, 그 결과를 utf8mb4 문자열로 반환합니다. 인수가 NULL이면 NULL을 반환합니다. 값이 큰따옴표로 시작하고 끝나지만 유효한 JSON 문자열 리터럴이 아니면 에러가 발생합니다.

문자열 내부에서, NO_BACKSLASH_ESCAPES SQL 모드가 활성화되어 있지 않은 한, 특정 시퀀스는 특별한 의미를 가집니다. 이러한 각각의 시퀀스는 백슬래시 (\)로 시작하며, 이를 이스케이프 문자 라고 합니다. MySQL 은 Table 14.23, “JSON_UNQUOTE() Special Character Escape Sequences”에 나와 있는 이스케이프 시퀀스들을 인식합니다. 그 외의 이스케이프 시퀀스에 대해서는 백슬래시가 무시됩니다. 즉, 이스케이프된 문자는 이스케이프되지 않은 것처럼 해석됩니다. 예를 들어, \x는 단지 x입니다. 이 시퀀스들은 대소문자를 구분합니다. 예를 들어, \b는 백스페이스로 해석되지만, \B는 B로 해석됩니다.

Table 14.23 JSON_UNQUOTE() Special Character Escape Sequences

Escape Sequence	Character Represented by Sequence
\"	큰따옴표 (") 문자
\b	백스페이스 문자
\f	폼피드 문자
\n	개행(newline, linefeed) 문자
\r	캐리지 리턴 문자
\t	탭 문자
\\	백슬래시 (\) 문자
\uXXXX	유니코드 값 XXXX 의 UTF-8 바이트

이 함수 사용에 대한 두 개의 간단한 예는 다음과 같습니다:

1mysql> SET @j = '"abc"';
2mysql> SELECT @j, JSON_UNQUOTE(@j);
3+-------+------------------+
4| @j    | JSON_UNQUOTE(@j) |
5+-------+------------------+
6| "abc" | abc              |
7+-------+------------------+
8mysql> SET @j = '[1, 2, 3]';
9mysql> SELECT @j, JSON_UNQUOTE(@j);
10+-----------+------------------+
11| @j        | JSON_UNQUOTE(@j) |
12+-----------+------------------+
13| [1, 2, 3] | [1, 2, 3]        |
14+-----------+------------------+

다음 예제 집합은, NO_BACKSLASH_ESCAPES가 비활성화된 경우와 활성화된 경우에 JSON_UNQUOTE가 이스케이프를 어떻게 처리하는지 보여줍니다:

1mysql> SELECT @@sql_mode;
2+------------+
3| @@sql_mode |
4+------------+
5|            |
6+------------+
7
8mysql> SELECT JSON_UNQUOTE('"\\t\\u0032"');
9+------------------------------+
10| JSON_UNQUOTE('"\\t\\u0032"') |
11+------------------------------+
12|   2                          |
13+------------------------------+
14
15mysql> SET @@sql_mode = 'NO_BACKSLASH_ESCAPES';
16mysql> SELECT JSON_UNQUOTE('"\\t\\u0032"');
17+------------------------------+
18| JSON_UNQUOTE('"\\t\\u0032"') |
19+------------------------------+
20| \t\u0032                     |
21+------------------------------+
22
23mysql> SELECT JSON_UNQUOTE('"\t\u0032"');
24+----------------------------+
25| JSON_UNQUOTE('"\t\u0032"') |
26+----------------------------+
27|   2                        |
28+----------------------------+