JSON 配列には、カンマで区切られ、[および]文字で囲まれた値のリストが含まれます:

["abc", 10, null, true, false]

JSON オブジェクトには、カンマで区切られ、{および} 文字で囲まれたキーと値のペアのセットが含まれます:

{"k1": "value", "k2": 10}

例に示すように、JSON 配列およびオブジェクトには、文字列または数値、JSON null リテラルまたは JSON ブール true または false リテラルであるスカラー値を含めることができます。 JSON オブジェクトのキーは文字列である必要があります。 時間的 (日付、時間または日時) スカラー値も使用できます:

["12:18:29.000000", "2015-07-29", "2015-07-29 12:18:29.000000"]

ネストは、JSON 配列要素および JSON オブジェクトキー値内で許可されます:

[99, {"id": "HK500", "cost": 75.99}, ["hot", "cold"]]
{"k1": "value", "k2": [10, 20]}

この目的 (セクション12.18.2「JSON 値を作成する関数」 を参照) のために MySQL によって提供される多数の関数から JSON 値を取得したり、CAST(value AS JSON) (JSON 値と非 JSON 値の間の変換 を参照) を使用して他のタイプの値を JSON タイプにキャストすることもできます。 次のいくつかの段落では、MySQL が入力として提供される JSON 値を処理する方法について説明します。

MySQL では、JSON 値は文字列として書き込まれます。 MySQL は、JSON 値を必要とするコンテキストで使用される文字列を解析し、JSON として有効でない場合はエラーを生成します。 次の例に示すように、これらのコンテキストには、JSON データ型を持つカラムへの値の挿入、および JSON 値を想定する関数への引数の受渡し (通常は MySQL JSON 関数のドキュメントで json_doc または json_val として示されています) が含まれます:

MySQL は、utf8mb4 文字セットおよび utf8mb4_bin 照合順序を使用して、JSON コンテキストで使用される文字列を処理します。 他の文字セットの文字列は、必要に応じて utf8mb4 に変換されます。 (ascii および utf8 は utf8mb4 のサブセットであるため、ascii または utf8 文字セットの文字列の場合、変換は必要ありません。)

リテラル文字列を使用して JSON 値を記述するかわりに、コンポーネント要素から JSON 値を構成するための関数が存在します。 JSON_ARRAY() は、(空の可能性がある) 値リストを取得し、これらの値を含む JSON 配列を返します:

mysql> SELECT JSON_ARRAY('a', 1, NOW());
+----------------------------------------+
| JSON_ARRAY('a', 1, NOW())              |
+----------------------------------------+
| ["a", 1, "2015-07-27 09:43:47.000000"] |
+----------------------------------------+

JSON_OBJECT() は、キーと値のペアの (空の可能性がある) リストを取得し、それらのペアを含む JSON オブジェクトを返します:

mysql> SELECT JSON_OBJECT('key1', 1, 'key2', 'abc');
+---------------------------------------+
| JSON_OBJECT('key1', 1, 'key2', 'abc') |
+---------------------------------------+
| {"key1": 1, "key2": "abc"}            |
+---------------------------------------+

JSON_MERGE_PRESERVE() は、複数の JSON ドキュメントを取得し、結合された結果を返します:

mysql> SELECT JSON_MERGE_PRESERVE('["a", 1]', '{"key": "value"}');
+-----------------------------------------------------+
| JSON_MERGE_PRESERVE('["a", 1]', '{"key": "value"}') |
+-----------------------------------------------------+
| ["a", 1, {"key": "value"}]                          |
+-----------------------------------------------------+
1 row in set (0.00 sec)

マージルールの詳細は、JSON 値の正規化、マージおよび自動ラップ を参照してください。

(MySQL 8.0.3 以降では、動作が多少異なる JSON_MERGE_PATCH() もサポートされます。 これらの関数の違いの詳細は、JSON_MERGE_PATCH() と JSON_MERGE_PRESERVE() の比較 を参照してください。)

JSON 値はユーザー定義変数に割り当てることができます:

mysql> SET @j = JSON_OBJECT('key', 'value');
mysql> SELECT @j;
+------------------+
| @j               |
+------------------+
| {"key": "value"} |
+------------------+

ただし、ユーザー定義変数は JSON データ型にできないため、前述の例の@j は JSON 値のように見え、JSON 値と同じ文字セットおよび照合順序を持ちますが、JSON データ型は持ちません。 かわりに、JSON_OBJECT() からの結果は、変数に割り当てられるときに文字列に変換されます。

JSON 値の変換によって生成される文字列には、utf8mb4 の文字セットと utf8mb4_bin の照合順序があります:

mysql> SELECT CHARSET(@j), COLLATION(@j);
+-------------+---------------+
| CHARSET(@j) | COLLATION(@j) |
+-------------+---------------+
| utf8mb4     | utf8mb4_bin   |
+-------------+---------------+

utf8mb4_bin はバイナリ照合であるため、JSON 値の比較では大/小文字が区別されます。

mysql> SELECT JSON_ARRAY('x') = JSON_ARRAY('X');
+-----------------------------------+
| JSON_ARRAY('x') = JSON_ARRAY('X') |
+-----------------------------------+
|                                 0 |
+-----------------------------------+

大/小文字の区別は、JSON null、true および false リテラルにも適用され、常に小文字で記述する必要があります:

mysql> SELECT JSON_VALID('null'), JSON_VALID('Null'), JSON_VALID('NULL');
+--------------------+--------------------+--------------------+
| JSON_VALID('null') | JSON_VALID('Null') | JSON_VALID('NULL') |
+--------------------+--------------------+--------------------+
|                  1 |                  0 |                  0 |
+--------------------+--------------------+--------------------+

mysql> SELECT CAST('null' AS JSON);
+----------------------+
| CAST('null' AS JSON) |
+----------------------+
| null                 |
+----------------------+
1 row in set (0.00 sec)

mysql> SELECT CAST('NULL' AS JSON);
ERROR 3141 (22032): Invalid JSON text in argument 1 to function cast_as_json:
"Invalid value." at position 0 in 'NULL'.

JSON リテラルの大/小文字の区別は、任意の文字で記述できる SQL NULL、TRUE および FALSE リテラルの区別とは異なります:

mysql> SELECT ISNULL(null), ISNULL(Null), ISNULL(NULL);
+--------------+--------------+--------------+
| ISNULL(null) | ISNULL(Null) | ISNULL(NULL) |
+--------------+--------------+--------------+
|            1 |            1 |            1 |
+--------------+--------------+--------------+

JSON ドキュメントに引用符文字 ("または') を挿入する必要がある場合や望ましい場合があります。 この例では、次に示す SQL ステートメントを使用して作成されたテーブルに、それぞれ適切なキーワードとペアになっている MySQL に関するファクトを示すステートメントを表す文字列を含む JSON オブジェクトを挿入するとします:

mysql> CREATE TABLE facts (sentence JSON);

キーワードと文のペアは次のとおりです:

mascot: The MySQL mascot is a dolphin named "Sakila".

これを JSON オブジェクトとして facts テーブルに挿入する方法の 1 つは、MySQL JSON_OBJECT() 関数を使用することです。 この場合、次に示すように、バックスラッシュを使用して各引用符文字をエスケープする必要があります:

mysql> INSERT INTO facts VALUES
     >   (JSON_OBJECT("mascot", "Our mascot is a dolphin named \"Sakila\"."));

JSON オブジェクトリテラルとして値を挿入する場合、これは同じように機能しません。この場合、次のように二重のバックスラッシュエスケープシーケンスを使用する必要があります:

mysql> INSERT INTO facts VALUES
     >   ('{"mascot": "Our mascot is a dolphin named \\"Sakila\\"."}');

二重バックスラッシュを使用すると、MySQL はエスケープシーケンス処理を実行せず、代わりに文字列リテラルを処理のためにストレージエンジンに渡します。 前述のいずれかの方法で JSON オブジェクトを挿入した後、次のように単純な SELECT を実行することで、JSON カラム値にバックスラッシュが存在することを確認できます:

mysql> SELECT sentence FROM facts;
+---------------------------------------------------------+
| sentence                                                |
+---------------------------------------------------------+
| {"mascot": "Our mascot is a dolphin named \"Sakila\"."} |
+---------------------------------------------------------+

mascot をキーとして使用するこの特定の文を検索するには、次に示すように、カラムパス演算子 -> を使用できます:

mysql> SELECT col->"$.mascot" FROM qtest;
+---------------------------------------------+
| col->"$.mascot"                             |
+---------------------------------------------+
| "Our mascot is a dolphin named \"Sakila\"." |
+---------------------------------------------+
1 row in set (0.00 sec)

これにより、バックスラッシュは引用符とともにそのまま残ります。 mascot をキーとして使用し、引用符やエスケープを含めずに目的の値を表示するには、次のようにインラインパス演算子 ->> を使用します:

mysql> SELECT sentence->>"$.mascot" FROM facts;
+-----------------------------------------+
| sentence->>"$.mascot"                   |
+-----------------------------------------+
| Our mascot is a dolphin named "Sakila". |
+-----------------------------------------+

mysql> INSERT INTO facts VALUES
     > (JSON_OBJECT('mascot', 'Our mascot is a dolphin named "Sakila".'));

文字列が解析され、有効な JSON ドキュメントであることが判明すると、文字列も正規化されます。 つまり、ドキュメントの後半で見つかったキーを複製するキーを持つメンバーは、左から右に読み取られて破棄されます。 次の JSON_OBJECT() コールによって生成されるオブジェクト値には、次に示すように、そのキー名が値の前に出現するため、2 番目の key1 要素のみが含まれます:

mysql> SELECT JSON_OBJECT('key1', 1, 'key2', 'abc', 'key1', 'def');
+------------------------------------------------------+
| JSON_OBJECT('key1', 1, 'key2', 'abc', 'key1', 'def') |
+------------------------------------------------------+
| {"key1": "def", "key2": "abc"}                       |
+------------------------------------------------------+

正規化は、次に示すように、値が JSON カラムに挿入されるときにも実行されます:

mysql> CREATE TABLE t1 (c1 JSON);

mysql> INSERT INTO t1 VALUES
     >     ('{"x": 17, "x": "red"}'),
     >     ('{"x": 17, "x": "red", "x": [3, 5, 7]}');

mysql> SELECT c1 FROM t1;
+------------------+
| c1               |
+------------------+
| {"x": "red"}     |
| {"x": [3, 5, 7]} |
+------------------+

この「「最後の重複キー優先」」の動作は、RFC 7159 によって推奨され、ほとんどの JavaScript パーサーによって実装されます。 (Bug #86866、Bug #26369555)

8.0.3 より前のバージョンの MySQL では、ドキュメント内で以前に見つかったキーを複製したキーを持つメンバーは破棄されました。 次の JSON_OBJECT() コールによって生成されたオブジェクト値には、2 番目の key1 要素は含まれません。これは、そのキー名が値の前にあるためです:

mysql> SELECT JSON_OBJECT('key1', 1, 'key2', 'abc', 'key1', 'def');
+------------------------------------------------------+
| JSON_OBJECT('key1', 1, 'key2', 'abc', 'key1', 'def') |
+------------------------------------------------------+
| {"key1": 1, "key2": "abc"}                           |
+------------------------------------------------------+

MySQL 8.0.3 より前は、この「「最初の重複キー優先」」正規化は JSON カラムに値を挿入するときにも実行されていました。

mysql> CREATE TABLE t1 (c1 JSON);

mysql> INSERT INTO t1 VALUES
     >     ('{"x": 17, "x": "red"}'),
     >     ('{"x": 17, "x": "red", "x": [3, 5, 7]}');

mysql> SELECT c1 FROM t1;
+-----------+
| c1        |
+-----------+
| {"x": 17} |
| {"x": 17} |
+-----------+

MySQL では、元の JSON ドキュメント内のキー、値または要素間の余分な空白も破棄され、各カンマ (,) またはコロン (:) の後に単一の空白が表示されたままになります (または必要に応じて挿入されます)。 これは、読みやすさを高めるために行われます。

JSON 値を生成する MySQL 関数 (セクション12.18.2「JSON 値を作成する関数」 を参照) は、常に正規化された値を返します。

ルックアップをより効率的にするために、MySQL では JSON オブジェクトのキーもソートされます。 この順序付けの結果は変更される可能性があり、リリース間での一貫性が保証されないことに注意してください。

JSON 値のマージ

関数 JSON_MERGE_PRESERVE() および JSON_MERGE_PATCH() によって実装される MySQL 8.0.3 (以降) では、2 つのマージアルゴリズムがサポートされています。 重複キーの処理方法が異なります: JSON_MERGE_PRESERVE() では重複キーの値が保持されますが、JSON_MERGE_PATCH() では最後の値以外のすべての値が破棄されます。 次のいくつかの段落では、これら 2 つの関数のそれぞれが JSON ドキュメント (つまり、オブジェクトと配列) の様々な組合せのマージを処理する方法について説明します。

配列のマージ.  複数の配列を組み合せるコンテキストでは、配列は単一の配列にマージされます。 JSON_MERGE_PRESERVE() では、後で名前を付けた配列を最初の配列の最後に連結することで、これを行います。 JSON_MERGE_PATCH() は、各引数を単一の要素で構成される配列とみなし (したがって、インデックスとして 0 を持つ)、「「最後の重複キー優先」」ロジックを適用して最後の引数のみを選択します。 次のクエリーで表示される結果を比較できます:

mysql> SELECT
    ->   JSON_MERGE_PRESERVE('[1, 2]', '["a", "b", "c"]', '[true, false]') AS Preserve,
    ->   JSON_MERGE_PATCH('[1, 2]', '["a", "b", "c"]', '[true, false]') AS Patch\G
*************************** 1. row ***************************
Preserve: [1, 2, "a", "b", "c", true, false]
   Patch: [true, false]

マージ時に複数のオブジェクトを使用すると、単一のオブジェクトが生成されます。 JSON_MERGE_PRESERVE() は、配列内のそのキーの一意の値をすべて組み合せることで、同じキーを持つ複数のオブジェクトを処理します。この配列は、結果でそのキーの値として使用されます。 JSON_MERGE_PATCH() では、左から右に向かって重複キーが見つかった値が破棄されるため、結果にはそのキーの最後の値のみが含まれます。 次のクエリーは、重複キー a の結果の違いを示しています:

mysql> SELECT
    ->   JSON_MERGE_PRESERVE('{"a": 1, "b": 2}', '{"c": 3, "a": 4}', '{"c": 5, "d": 3}') AS Preserve,
    ->   JSON_MERGE_PATCH('{"a": 3, "b": 2}', '{"c": 3, "a": 4}', '{"c": 5, "d": 3}') AS Patch\G
*************************** 1. row ***************************
Preserve: {"a": [1, 4], "b": 2, "c": [3, 5], "d": 3}
   Patch: {"a": 4, "b": 2, "c": 5, "d": 3}

配列値を必要とするコンテキストで使用される非配列値は、自動ラップされます: この値は、配列に変換するために[および]文字で囲まれています。 次のステートメントでは、各引数が配列 ([1]、[2]) として自動ラップされます。 これらはマージされて単一の結果配列が生成されます。前述の 2 つの場合と同様に、JSON_MERGE_PRESERVE() は同じキーを持つ値を結合し、JSON_MERGE_PATCH() は最後のキーを除くすべての重複キーの値を破棄します:

mysql> SELECT
	  ->   JSON_MERGE_PRESERVE('1', '2') AS Preserve,
	  ->   JSON_MERGE_PATCH('1', '2') AS Patch\G
*************************** 1. row ***************************
Preserve: [1, 2]
   Patch: 2

配列およびオブジェクト値をマージするには、次の例に示すように、オブジェクトを配列として自動ラップし、マージ機能の選択に従って値を組み合せるか、「「最後の重複キー優先」」によって配列をマージします (それぞれ JSON_MERGE_PRESERVE() または JSON_MERGE_PATCH()):

mysql> SELECT
	  ->   JSON_MERGE_PRESERVE('[10, 20]', '{"a": "x", "b": "y"}') AS Preserve,
	  ->   JSON_MERGE_PATCH('[10, 20]', '{"a": "x", "b": "y"}') AS Patch\G
*************************** 1. row ***************************
Preserve: [10, 20, {"a": "x", "b": "y"}]
   Patch: {"a": "x", "b": "y"}

JSON パス式は、JSON ドキュメント内の値を選択します。

パス式は、JSON ドキュメントの一部を抽出または変更して、そのドキュメント内のどこで操作するかを指定する関数で役立ちます。 たとえば、次のクエリーは、name キーを持つメンバーの値を JSON ドキュメントから抽出します:

mysql> SELECT JSON_EXTRACT('{"id": 14, "name": "Aztalan"}', '$.name');
+---------------------------------------------------------+
| JSON_EXTRACT('{"id": 14, "name": "Aztalan"}', '$.name') |
+---------------------------------------------------------+
| "Aztalan"                                               |
+---------------------------------------------------------+

パス構文では、検討中の JSON ドキュメントを表すために先頭の $ 文字が使用され、オプションで、ドキュメントの連続して具体的な部分を示すセレクタが続きます:

$ では、次の 3 つの要素を使用してこの JSON 配列を参照します:

[3, {"a": [5, 6], "b": 10}, [99, 100]]

このとき、次のようになります。

$[1]および $[2]は非スカラー値と評価されるため、ネストされた値を選択するより具体的なパス式の基礎として使用できます。 例:

前述のように、引用符で囲まれていないキー名がパス式で有効でない場合は、キーに名前を付けるパスコンポーネントを引用符で囲む必要があります。 $ がこの値を参照するようにします:

{"a fish": "shark", "a bird": "sparrow"}

キーにはスペースが含まれているため、引用符で囲む必要があります:

ワイルドカードを使用するパスは、複数の値を含むことができる配列に評価されます:

mysql> SELECT JSON_EXTRACT('{"a": 1, "b": 2, "c": [3, 4, 5]}', '$.*');
+---------------------------------------------------------+
| JSON_EXTRACT('{"a": 1, "b": 2, "c": [3, 4, 5]}', '$.*') |
+---------------------------------------------------------+
| [1, 2, [3, 4, 5]]                                       |
+---------------------------------------------------------+
mysql> SELECT JSON_EXTRACT('{"a": 1, "b": 2, "c": [3, 4, 5]}', '$.c[*]');
+------------------------------------------------------------+
| JSON_EXTRACT('{"a": 1, "b": 2, "c": [3, 4, 5]}', '$.c[*]') |
+------------------------------------------------------------+
| [3, 4, 5]                                                  |
+------------------------------------------------------------+

次の例では、$**.b が複数のパス ($.a.b および $.c.b) に評価し、一致するパス値の配列を生成します:

mysql> SELECT JSON_EXTRACT('{"a": {"b": 1}, "c": {"b": 2}}', '$**.b');
+---------------------------------------------------------+
| JSON_EXTRACT('{"a": {"b": 1}, "c": {"b": 2}}', '$**.b') |
+---------------------------------------------------------+
| [1, 2]                                                  |
+---------------------------------------------------------+

JSON 配列からの範囲.  範囲を to キーワードとともに使用して、JSON 配列のサブセットを指定できます。 たとえば、次に示すように、$[1 to 3]には配列の 2 番目、3 番目および 4 番目の要素が含まれます:

mysql> SELECT JSON_EXTRACT('[1, 2, 3, 4, 5]', '$[1 to 3]');
+----------------------------------------------+
| JSON_EXTRACT('[1, 2, 3, 4, 5]', '$[1 to 3]') |
+----------------------------------------------+
| [2, 3, 4]                                    |
+----------------------------------------------+
1 row in set (0.00 sec)

構文は M to N です。ここで、M と N はそれぞれ、JSON 配列の要素の範囲の最初と最後のインデックスです。 N は M より大きい必要があります。M は 0 以上である必要があります。 配列要素は 0 から始まるインデックス付けされます。

ワイルドカードがサポートされているコンテキストで範囲を使用できます。

右端の配列要素.  last キーワードは、配列の最後の要素のインデックスのシノニムとしてサポートされています。 last - N 形式の式は、次のように、相対アドレス指定および範囲定義内で使用できます:

mysql> SELECT JSON_EXTRACT('[1, 2, 3, 4, 5]', '$[last-3 to last-1]');
+--------------------------------------------------------+
| JSON_EXTRACT('[1, 2, 3, 4, 5]', '$[last-3 to last-1]') |
+--------------------------------------------------------+
| [2, 3, 4]                                              |
+--------------------------------------------------------+
1 row in set (0.01 sec)

パスが配列ではない値に対して評価される場合、評価の結果は値が単一要素配列にラップされた場合と同じです:

mysql> SELECT JSON_REPLACE('"Sakila"', '$[last]', 10);
+-----------------------------------------+
| JSON_REPLACE('"Sakila"', '$[last]', 10) |
+-----------------------------------------+
| 10                                      |
+-----------------------------------------+
1 row in set (0.00 sec)

column->path は、JSON カラム識別子および JSON パス式とともに JSON_EXTRACT(column, path) のシノニムとして使用できます。 詳しくはセクション12.18.3「JSON 値を検索する関数」,をご覧ください。 JSON カラムインデックスを提供するための生成されたカラムのインデックス付けも参照してください。

一部の関数では、既存の JSON ドキュメントを取得し、なんらかの方法で変更して、結果として変更されたドキュメントを戻します。 パス式は、変更を加えるドキュメント内の場所を示します。 たとえば、JSON_SET()、JSON_INSERT() および JSON_REPLACE() の各関数は、JSON ドキュメントに加えて、ドキュメントを変更する場所と使用する値を記述する 1 つ以上のパスと値のペアを取ります。 関数は、ドキュメント内の既存の値と存在しない値の処理方法が異なります。

このドキュメントについて考えてみます:

mysql> SET @j = '["a", {"b": [true, false]}, [10, 20]]';

JSON_SET() は、存在するパスの値を置き換え、存在しないパスの値を追加します。

mysql> SELECT JSON_SET(@j, '$[1].b[0]', 1, '$[2][2]', 2);
+--------------------------------------------+
| JSON_SET(@j, '$[1].b[0]', 1, '$[2][2]', 2) |
+--------------------------------------------+
| ["a", {"b": [1, false]}, [10, 20, 2]]      |
+--------------------------------------------+

この場合、パス $[1].b[0]は既存の値 (true) を選択します。これは、パス引数 (1) の後の値に置き換えられます。 パス $[2][2]が存在しないため、$[2]によって選択された値に対応する値 (2) が追加されます。

JSON_INSERT() によって新しい値が追加されますが、既存の値は置換されません:

mysql> SELECT JSON_INSERT(@j, '$[1].b[0]', 1, '$[2][2]', 2);
+-----------------------------------------------+
| JSON_INSERT(@j, '$[1].b[0]', 1, '$[2][2]', 2) |
+-----------------------------------------------+
| ["a", {"b": [true, false]}, [10, 20, 2]]      |
+-----------------------------------------------+

JSON_REPLACE() は既存の値を置換し、新しい値を無視します:

mysql> SELECT JSON_REPLACE(@j, '$[1].b[0]', 1, '$[2][2]', 2);
+------------------------------------------------+
| JSON_REPLACE(@j, '$[1].b[0]', 1, '$[2][2]', 2) |
+------------------------------------------------+
| ["a", {"b": [1, false]}, [10, 20]]             |
+------------------------------------------------+

パスと値のペアは左から右に評価されます。 あるペアを評価して生成されたドキュメントは、次のペアが評価される新しい値になります。

JSON_REMOVE() は、JSON ドキュメントと、ドキュメントから削除する値を指定する 1 つ以上のパスを取ります。 戻り値は、元のドキュメントから、ドキュメント内に存在するパスによって選択された値を引いたものです:

mysql> SELECT JSON_REMOVE(@j, '$[2]', '$[1].b[1]', '$[1].b[1]');
+---------------------------------------------------+
| JSON_REMOVE(@j, '$[2]', '$[1].b[1]', '$[1].b[1]') |
+---------------------------------------------------+
| ["a", {"b": [true]}]                              |
+---------------------------------------------------+

パスには次の効果があります:

MySQL でサポートされ、このマニュアルの他の場所で説明されている JSON 関数の多く (セクション12.18「JSON 関数」 を参照) では、JSON ドキュメント内の特定の要素を識別するためにパス式が必要です。 パスは、パススコープとそれに続く 1 つ以上のパスレッグで構成されます。 MySQL JSON 関数で使用されるパスの場合、有効範囲は常に検索または操作されるドキュメントで、先頭の $ 文字で表されます。 パスレグはピリオド文字 (.) で区切られます。 配列内のセルは[N]で表され、N は負でない整数です。 キーの名前は、二重引用符で囲まれた文字列または有効な ECMAScript 識別子である必要があります (「ECMAScript 言語仕様」の「識別子名および識別子」を参照)。 JSON テキストなどのパス式は、ascii、utf8 または utf8mb4 文字セットを使用してエンコードする必要があります。 その他の文字エンコーディングは、暗黙的に utf8mb4 に強制変換されます。 完全な構文は次のとおりです:

pathExpression:
    scope[(pathLeg)*]

pathLeg:
    member | arrayLocation | doubleAsterisk

member:
    period ( keyName | asterisk )

arrayLocation:
    leftBracket ( nonNegativeInteger | asterisk ) rightBracket

keyName:
    ESIdentifier | doubleQuotedString

doubleAsterisk:
    '**'

period:
    '.'

asterisk:
    '*'

leftBracket:
    '['

rightBracket:
    ']'

前述のように、MySQL では、パスのスコープは常に操作対象のドキュメントで、$ として表されます。 '$'を JSON パス式のドキュメントの構文として使用できます。

ワイルドカード * および ** トークンは、次のように使用されます:

パス構文の例は、JSON_CONTAINS_PATH()、JSON_SET()、JSON_REPLACE() などの引数としてパスを取る様々な JSON 関数の説明を参照してください。 * および ** ワイルドカードの使用を含む例は、JSON_SEARCH() 関数の説明を参照してください。

MySQL 8.0.2 以降では、to キーワード ($[2 to 10]など) を使用した JSON 配列のサブセットの範囲表記、および配列の右端の要素のシノニムとして last キーワードもサポートされています。 詳細および例については、JSON 値の検索および変更を参照してください。

JSON 値は、=, <, <=, >, >=, <>, != および <=> 演算子を使用して比較できます。

次の比較演算子および関数は、JSON 値ではまだサポートされていません:

リストされている比較演算子および関数の回避策は、JSON 値をネイティブの MySQL 数値または文字列データ型にキャストして、JSON 以外のスカラー型が一貫しているようにすることです。

JSON 値の比較は 2 つのレベルで行われます。 最初のレベルの比較は、比較された値の JSON 型に基づきます。 タイプが異なる場合、比較結果は優先順位の高いタイプによってのみ決定されます。 2 つの値が同じ JSON 型である場合、2 つ目のレベルの比較は型固有のルールを使用して行われます。

次のリストは、JSON 型の優先順位の高いものから低いものへの優先順位を示しています。 (型名は、JSON_TYPE() 関数によって戻される型名です。) 行にまとめて表示されるタイプの優先順位は同じです。 リストの前半にリストされている JSON 型を持つ値は、リストの後半にリストされている JSON 型を持つ値よりも大きく比較されます。

BLOB
BIT
OPAQUE
DATETIME
TIME
DATE
BOOLEAN
ARRAY
OBJECT
STRING
INTEGER, DOUBLE
NULL

同じ優先順位の JSON 値の場合、比較ルールはタイプ固有です:

JSON 値を SQL NULL と比較する場合、結果は UNKNOWN になります。

JSON 値と非 JSON 値を比較するために、非 JSON 値は次のテーブルのルールに従って JSON に変換されてから、前述のように比較されます。

次のテーブルに、JSON 値と他のタイプの値の間のキャスト時に MySQL が従うルールのサマリーを示します:

JSON 値の ORDER BY および GROUP BY は、次の原則に従って機能します:

ソートの場合、JSON スカラーを他のネイティブ MySQL 型にキャストすると便利です。 たとえば、jdoc という名前のカラムに、id キーと負でない値で構成されるメンバーを持つ JSON オブジェクトが含まれる場合、次の式を使用して id 値でソートします:

ORDER BY CAST(JSON_EXTRACT(jdoc, '$.id') AS UNSIGNED)

生成されたカラムが ORDER BY と同じ式を使用するように定義されている場合、MySQL オプティマイザはそれを認識し、クエリー実行計画のインデックスの使用を検討します。 セクション8.3.11「生成されたカラムインデックスのオプティマイザによる使用」を参照してください。

JSON 値の集計では、SQL NULL 値は他のデータ型と同様に無視されます。 NULL 以外の値は数値型に変換され、MIN()、MAX() および GROUP_CONCAT() を除いて集計されます。 数値への変換では、数値スカラーである JSON 値に対して意味のある結果が生成される必要がありますが、(値によっては) 精度の切捨ておよび損失が発生する可能性があります。 他の JSON 値の数に変換しても、意味のある結果が得られない場合があります。