MySQL 8.0のCharset utf8mb4での日本語環境で使うCollationで文字比較をしてみる

これは、なにをしたくて書いたもの？

MySQL 8.0のCharset utf8mb4で使えるCollationについて、ちょっと見ておこうかなと思いまして。

具体的には、「MySQL徹底入門 第4版」の「11.2 Collation」に書かれている文字比較およびソートについて自分で
確認してみたいと思います。

MySQL徹底入門 第4版 MySQL 8.0対応

utf8mb4でのCharsetとCollation

MySQLのCharsetとCollationに関するドキュメントは、こちらです。

MySQL :: MySQL 8.0 リファレンスマニュアル :: 10 文字セット、照合順序、Unicode

MySQLでは複数のCharset（文字セット）を使うことができ、その環境で使用できるCharsetは以下で確認できます。

mysql> show character set;

そして、CharsetにはCollation（照合順序）があり、文字の比較やソートに関わってくることになります。

MySQL :: MySQL 8.0 リファレンスマニュアル :: 10.2 MySQL での文字セットと照合順序

使用できるCollationは、以下で確認できます。

mysql> show collation;

CharsetおよびCollationは、サーバー、データベース、テーブル、カラム、文字列リテラルそれぞれで指定することが
できます。

MySQL :: MySQL 8.0 リファレンスマニュアル :: 10.3 文字セットと照合順序の指定

で、どのCharset、Collationを使うかですが…。

まずはCharset。

Unicodeをサポートする、UTF-8系のCharsetを選ぶことになるでしょう。
というか、utf8mb4（4バイトのUTF-8エンコーディング）ですね。

MySQL :: MySQL 8.0 リファレンスマニュアル :: 10.9 Unicode のサポート

昨今はあまり使わないかもしれませんが、cp932、eucjpmsなどもあります。

MySQL :: MySQL 8.0 リファレンスマニュアル :: 10.10.7 アジアの文字セット

今回は、utf8mb4を扱うことにします。

続いてCollation。

utf8mb4_bin、utf8mb4_general_ci、utf8mb4_0900_as_ci、utf8mb4_ja_0900_as_cs、utf8mb4_ja_0900_as_cs_ksなどが
あるわけですが、これらの読み方は以下を見るとわかります。

MySQL :: MySQL 8.0 リファレンスマニュアル :: 10.3.1 照合の命名規則

まず、Collationの名前は関連付けられているCharsetで始まります。

照合順序名は、関連付けられている文字セットの名前で始まり、通常は、他の照合順序特性を示す 1 つ以上の接尾辞が続きます。

jaなどのLocaleが含まれる場合は、言語固有のCollationであることを表しています。

言語固有の照合には、ロケールコードまたは言語名が含まれます。

そのあとのサフィックス（接尾辞）は、以下の意味になります。

• _ai … アクセントを区別しない（Accent Insensitive）
• _as … アクセントを区別する（Accent Sensitive）
• _ci … 大文字・小文字を区別しない（Case Insensitive）
• _cs … 大文字・小文字を区別する（Case Sensitive）
• _ks … カナを区別する（Kana Sensitive）
• _bin … バイナリ

日本語について言うと、アクセントは清音濁音半濁音、かなは平仮名片仮名、これらを区別するかどうかという
話になります。

数字が入っている場合は、Unicode Collation Algorithm（Unicode照合アルゴリズム、UCA）のバージョンを示しています。

• utf8mb4_unicode_520_ci … Unicode Collation Algorithm 5.2.0に基づいている
• utf8mb4_ja_0900_as_cs … Unicode Collation Algorithm 9.0.0に基づいている

つまり、UCAのバージョンが入っているものについては、Unicode規格に沿ったCollationだというわけですね。

ここまでの内容を踏まえると、たとえばutf8mb4_ja_0900_as_cs_ksだと以下のような解釈になります。

• 日本語固有のCollation
• UCA 9.0.0に基づいている
• アクセントを区別する
• 大文字・小文字を区別する
• カナを区別する

とすると、UCAのバージョンが入っていないCollationはどういうものかというと、UCAの規格に従わないMySQL独自の
規則のものだということになります。

_binについてはバイナリなので、utf8mb4_bin、utf8mb4_0900_binはバイナリ比較となります。

この2つの違いは、以下に記載があります。

• _bin (バイナリ) 照合順序を除くすべての Unicode 照合順序について、MySQL はテーブル検索を実行して文字照合順序を検索します。
• utf8mb4_0900_bin 以外の_bin 照合順序の場合、重みはコードポイントに基づき、先行するゼロバイトが追加される場合があります。
• utf8mb4_0900_bin の場合、重みは utf8mb4 エンコーディングバイトです。 ソート順序は utf8mb4_bin の場合と同じですが、はるかに高速です。

文字照合ウェイト

コードポイントでの比較か、バイトでの比較かという違いですね。また、utf8mb4_binはPAD SPACE、
utf8mb4_0900_binはNO PADという違いもあります（照合パッド属性については後述）。

あとは、utf8mb4_general_ci、utf8mb4_unicode_ciといったCollationについて。

MySQL :: MySQL 8.0 リファレンスマニュアル :: 10.10.1 Unicode 文字セット

これらについては、以下に記載があります。

_general_ci と unicode_ci の照合順序

xxx_general_ciの方がxxx_unicode_ciよりも高速なようですが、精度も低くなるとか。

Unicode 文字セットの場合、xxx_general_ci 照合順序を使用して実行する演算は、xxx_unicode_ci 照合順序のものよりも高速です。 たとえば、utf8_general_ci 照合順序の比較は、utf8_unicode_ci の比較よりも高速ですが、精度は少し低くなります。これは、utf8_unicode_ci で拡張などのマッピングがサポートされているためです。

これだと、ちょっとよくわからないですね。

以下に、こんな記述がありました。

一般照合 (xxx_general_ci) の BMP 文字の場合、重みはコードポイントです。

文字照合ウェイト

つまり、BMPの範囲ではコードポイントでの比較を行うようです。

• utf8mb4_general_ci … 大文字・小文字を区別せず（_ci）、他はBMPのコードポイントに沿って比較を行う。ただし、BMPの範囲外（U+10000`以上の文字）は区別できない
• utf8mb4_unicode_ci … Unicode拡張をサポートしたもの

こう書くとutf8mb4_unicode_ciの方が良さそうですが、実際にはいろいろ困ったことになるので使わないでしょう…。

また、CollationにはPAD属性があり、NO PADのものは文字列の末尾にあるスペースが文字として扱われます。

UCA 9.0.0 以上に基づく照合は、9.0.0 より前の UCA バージョンに基づく照合より高速です。 また、9.0.0 より前の UCA バージョンに基づく照合で使用される PAD SPACE とは対照的に、NO PAD のパッド属性もあります。 非バイナリ文字列を比較するために、NO PAD 照合順序では、文字列の末尾のスペースは他の文字と同様に扱われます。

照合パッド属性

要するに、最後のスペースを比較に含めるかどうか、という話です。

そして先に少しドキュメントを出してしまいましたが、Collationにおける文字の重みはWEIGHT_STRING関数を使って
調べることができます。

文字照合ウェイト

WEIGHT_STRING

実際の文字の判定がどうなっているのかを確認するには、こちらを使うとよいでしょう。

デフォルトのutf8mb4のCollation

Charset utf8mb4を選んだ場合、デフォルトのCollationはutf8mb4_0900_ai_ciとなるようです。

mysql> show collation where collation like 'utf8mb4%' and `default` = 'Yes';
+--------------------+---------+-----+---------+----------+---------+---------------+
| Collation          | Charset | Id  | Default | Compiled | Sortlen | Pad_attribute |
+--------------------+---------+-----+---------+----------+---------+---------------+
| utf8mb4_0900_ai_ci | utf8mb4 | 255 | Yes     | Yes      |       0 | NO PAD        |
+--------------------+---------+-----+---------+----------+---------+---------------+
1 row in set (0.00 sec)

ここから先は、実際に動かしながら確認してみましょう。

環境

今回の環境について。

MySQL 8.0.24を使います。こちらは、172.17.0.2で動作しているものとします。

また、確認のための情報はプログラムで作成することにします。今回はPythonを使うことにしました。

$ python3 -V
Python 3.8.5


$ pip3 -V
pip 20.0.2 from /path/to/venv/lib/python3.8/site-packages/pip (python 3.8)

MySQLへのアクセスには、MySQL Connector/Pythonを使います。

MySQL :: MySQL Connector/Python Developer Guide

$ pip3 install mysql-connector-python==8.0.24

プログラム自体は、最後に載せることにします。

今回扱うCollation

今回扱うCollationは、こちらにします。

mysql>  show collation
    ->  where
    ->   collation like 'utf8mb4_ja%' or
    ->   collation like 'utf8mb4_0900%' or
    ->   collation like 'utf8mb4%bin' or
    ->   collation like 'utf8mb4%general%' or
    ->   collation like 'utf8mb4%unicode%';
+--------------------------+---------+-----+---------+----------+---------+---------------+
| Collation                | Charset | Id  | Default | Compiled | Sortlen | Pad_attribute |
+--------------------------+---------+-----+---------+----------+---------+---------------+
| utf8mb4_0900_ai_ci       | utf8mb4 | 255 | Yes     | Yes      |       0 | NO PAD        |
| utf8mb4_0900_as_ci       | utf8mb4 | 305 |         | Yes      |       0 | NO PAD        |
| utf8mb4_0900_as_cs       | utf8mb4 | 278 |         | Yes      |       0 | NO PAD        |
| utf8mb4_0900_bin         | utf8mb4 | 309 |         | Yes      |       1 | NO PAD        |
| utf8mb4_bin              | utf8mb4 |  46 |         | Yes      |       1 | PAD SPACE     |
| utf8mb4_general_ci       | utf8mb4 |  45 |         | Yes      |       1 | PAD SPACE     |
| utf8mb4_ja_0900_as_cs    | utf8mb4 | 303 |         | Yes      |       0 | NO PAD        |
| utf8mb4_ja_0900_as_cs_ks | utf8mb4 | 304 |         | Yes      |      24 | NO PAD        |
| utf8mb4_unicode_520_ci   | utf8mb4 | 246 |         | Yes      |       8 | PAD SPACE     |
| utf8mb4_unicode_ci       | utf8mb4 | 224 |         | Yes      |       8 | PAD SPACE     |
+--------------------------+---------+-----+---------+----------+---------+---------------+
10 rows in set (0.01 sec)

少し比較してみる

ここまでの説明を踏まえて、一部のCollationを少し確認してみましょう。

utf8mb4_0900_ai_ci。アクセント区別なし、大文字・小文字区別なし、ですね。また、NO PADでもあります。

mysql> set names utf8mb4 collate utf8mb4_0900_ai_ci;
Query OK, 0 rows affected (0.00 sec)


mysql> select 'a' = 'A';
+-----------+
| 'a' = 'A' |
+-----------+
|         1 |
+-----------+
1 row in set (0.00 sec)


mysql> select 'あ' = 'ぁ';
+---------------+
| 'あ' = 'ぁ'   |
+---------------+
|             1 |
+---------------+
1 row in set (0.00 sec)


mysql> select 'は' = 'ば';
+---------------+
| 'は' = 'ば'   |
+---------------+
|             1 |
+---------------+
1 row in set (0.00 sec)


mysql> select 'a  ' = 'A';
+-------------+
| 'a  ' = 'A' |
+-------------+
|           0 |
+-------------+
1 row in set (0.00 sec)


mysql> select '🍣' = '🍺';
+-----------+
| '?' = '?' |
+-----------+
|         0 |
+-----------+
1 row in set (0.00 sec)

結果が1なのは、Trueを表しています。

大文字、小文字が区別されず、「あ」と「ぁ」、「は」と「ば」も区別されず。末尾のスペースは区別されました。
🍣と🍺も区別されましたね。

今度は、utf8mb4_general_ciにしてみましょう。

mysql> set names utf8mb4 collate utf8mb4_general_ci;
Query OK, 0 rows affected (0.00 sec)


mysql> select 'a' = 'A';
+-----------+
| 'a' = 'A' |
+-----------+
|         1 |
+-----------+
1 row in set (0.00 sec)


mysql> select 'あ' = 'ぁ';
+---------------+
| 'あ' = 'ぁ'   |
+---------------+
|             0 |
+---------------+
1 row in set (0.00 sec)


mysql> select 'は' = 'ば';
+---------------+
| 'は' = 'ば'   |
+---------------+
|             0 |
+---------------+
1 row in set (0.00 sec)


mysql> select 'a  ' = 'A';
+-------------+
| 'a  ' = 'A' |
+-------------+
|           1 |
+-------------+
1 row in set (0.00 sec)


mysql> select '🍣' = '🍺';
+-----------+
| '?' = '?' |
+-----------+
|         1 |
+-----------+
1 row in set (0.01 sec)

大文字、小文字は区別されません。「あ」と「ぁ」、「は」と「ば」は区別されました。
末尾のスペースは区別されていますね。🍣と🍺は同じ文字になってしまいました。

もうひとつ、utf8mb4_0900_as_cs。アクセント、大文字・小文字を区別するものに。

mysql> set names utf8mb4 collate utf8mb4_0900_as_cs;
Query OK, 0 rows affected (0.00 sec)


mysql> select 'a' = 'A';
+-----------+
| 'a' = 'A' |
+-----------+
|         0 |
+-----------+
1 row in set (0.00 sec)

mysql> select 'あ' = 'ぁ';
+---------------+
| 'あ' = 'ぁ'   |
+---------------+
|             0 |
+---------------+
1 row in set (0.00 sec)


mysql> select 'は' = 'ば';
+---------------+
| 'は' = 'ば'   |
+---------------+
|             0 |
+---------------+
1 row in set (0.00 sec)


mysql> select 'a  ' = 'A';
+-------------+
| 'a  ' = 'A' |
+-------------+
|           0 |
+-------------+
1 row in set (0.00 sec)


mysql> select '🍣' = '🍺';
+-----------+
| '?' = '?' |
+-----------+
|         0 |
+-----------+
1 row in set (0.00 sec)

あとは、weight_string関数で重みを見てみましょう。

mysql> set names utf8mb4 collate utf8mb4_general_ci;
Query OK, 0 rows affected (0.00 sec)


mysql> select 'a', hex('a'), hex(weight_string('a'));
+---+----------+-------------------------+
| a | hex('a') | hex(weight_string('a')) |
+---+----------+-------------------------+
| a | 61       | 0041                    |
+---+----------+-------------------------+
1 row in set (0.00 sec)


mysql> select 'A', hex('A'), hex(weight_string('A'));
+---+----------+-------------------------+
| A | hex('A') | hex(weight_string('A')) |
+---+----------+-------------------------+
| A | 41       | 0041                    |
+---+----------+-------------------------+
1 row in set (0.00 sec)

mysql> select 'あ', hex('あ'), hex(weight_string('あ'));
+-----+------------+---------------------------+
| あ  | hex('あ')  | hex(weight_string('あ'))  |
+-----+------------+---------------------------+
| あ  | E38182     | 3042                      |
+-----+------------+---------------------------+
1 row in set (0.00 sec)


mysql> select 'ぁ', hex('ぁ'), hex(weight_string('ぁ'));
+-----+------------+---------------------------+
| ぁ  | hex('ぁ')  | hex(weight_string('ぁ'))  |
+-----+------------+---------------------------+
| ぁ  | E38181     | 3041                      |
+-----+------------+---------------------------+
1 row in set (0.00 sec)


mysql> select '🍣', hex('🍣'), hex(weight_string('🍣'));
+------+----------+-------------------------+
| ?    | hex('?') | hex(weight_string('?')) |
+------+----------+-------------------------+
| 🍣     | F09F8DA3 | FFFD                    |
+------+----------+-------------------------+
1 row in set (0.00 sec)


mysql> select '🍺', hex('🍺'), hex(weight_string('🍺'));
+------+----------+-------------------------+
| ?    | hex('?') | hex(weight_string('?')) |
+------+----------+-------------------------+
| 🍺     | F09F8DBA | FFFD                    |
+------+----------+-------------------------+
1 row in set (0.00 sec)

こう見ると、文字が区別される、されない理由がわかりますね。また、utf8mb4_general_ciだとBMP外の文字は\ufffdに
なってしまうようです。

もっと比較してみる

では、もっとCollationを広げて比較してみましょう。

以下のCollationを対象にします。

• utf8mb4_0900_ai_ci
• utf8mb4_0900_as_ci
• utf8mb4_0900_as_cs
• utf8mb4_ja_0900_as_cs
• utf8mb4_ja_0900_as_cs_ks
• utf8mb4_bin
• utf8mb4_0900_bin
• utf8mb4_general_ci
• utf8mb4_unicode_ci
• utf8mb4_unicode_520_ci

これらのCollationに対して、以下の文字の等値比較・大小を算出みたいと思います。
※「MySQL徹底入門 第4版」に書かれていた、「令和」関係の文字は手元の環境だと入力できませんでした…

• Aとa
• AとＡ（全角）
• Ａ（全角）とａ（全角）
• あとぁ
• あとア
• はとば
• ばとぱ
• 1と①
• 0と〇（漢数字）
• 平成と㍻
• 🍣と🍺

また、上記の文字に対してweight_stringで重みも算出します。

結果は、こちら。

文字比較。

utf8mb4_unicode_ciが、ほとんど区別できてないですね。utf8mb4_unicode_520_ciは、🍣と🍺だけ区別できていますが。

表が大きくなったので画像にしましたが、Markdownのままでも貼っておきましょう。

| 比較 | utf8mb4_0900_ai_ci | utf8mb4_0900_as_ci | utf8mb4_0900_as_cs | utf8mb4_ja_0900_as_cs | utf8mb4_ja_0900_as_cs_ks | utf8mb4_bin | utf8mb4_0900_bin | utf8mb4_general_ci | utf8mb4_unicode_ci | utf8mb4_unicode_520_ci |
|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|
| A = a  | ○ | ○ | × | × | × | × | × | ○ | ○ | ○ |
| A = Ａ  | ○ | ○ | × | ○ | ○ | × | × | × | ○ | ○ |
| Ａ = ａ  | ○ | ○ | × | × | × | × | × | ○ | ○ | ○ |
| あ = ぁ  | ○ | ○ | × | × | × | × | × | × | ○ | ○ |
| あ = ア  | ○ | ○ | × | ○ | × | × | × | × | ○ | ○ |
| は = ば  | ○ | × | × | × | × | × | × | × | ○ | ○ |
| ば = ぱ  | ○ | × | × | × | × | × | × | × | ○ | ○ |
| 1 = ①  | ○ | ○ | × | × | × | × | × | × | ○ | ○ |
| 0 = 〇  | ○ | ○ | ○ | ○ | ○ | × | × | × | ○ | ○ |
| 平成 = ㍻  | ○ | ○ | × | × | × | × | × | × | ○ | ○ |
| 🍣 = 🍺  | × | × | × | × | × | × | × | ○ | ○ | × |

大小比較。

Markdownで。

| 比較 | utf8mb4_0900_ai_ci | utf8mb4_0900_as_ci | utf8mb4_0900_as_cs | utf8mb4_ja_0900_as_cs | utf8mb4_ja_0900_as_cs_ks | utf8mb4_bin | utf8mb4_0900_bin | utf8mb4_general_ci | utf8mb4_unicode_ci | utf8mb4_unicode_520_ci |
|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|
| A comp a  | = | = | > | > | > | < | < | = | = | = |
| A comp Ａ  | = | = | < | = | = | < | < | < | = | = |
| Ａ comp ａ  | = | = | > | > | > | < | < | = | = | = |
| あ comp ぁ  | = | = | > | > | > | > | > | > | = | = |
| あ comp ア  | = | = | < | = | < | < | < | < | = | = |
| は comp ば  | = | < | < | < | < | < | < | < | = | = |
| ば comp ぱ  | = | < | < | < | < | < | < | < | = | = |
| 1 comp ①  | = | = | < | < | < | < | < | < | = | = |
| 0 comp 〇  | = | = | = | = | = | < | < | < | = | = |
| 平成 comp ㍻  | = | = | < | < | < | > | > | > | = | = |
| 🍣 comp 🍺  | < | < | < | < | < | < | < | = | = | < |

最後は、文字の重み。

これは、ちょっと見えませんね…。Markdownで。

| 文字（hex） | utf8mb4_0900_ai_ci（weight） | utf8mb4_0900_as_ci（weight） | utf8mb4_0900_as_cs（weight） | utf8mb4_ja_0900_as_cs（weight） | utf8mb4_ja_0900_as_cs_ks（weight） | utf8mb4_bin（weight） | utf8mb4_0900_bin（weight） | utf8mb4_general_ci（weight） | utf8mb4_unicode_ci（weight） | utf8mb4_unicode_520_ci（weight） |
|:----|:----|:----|:----|:----|:----|:----|:----|:----|:----|:----|
| A(41) | 1C47 | 1C4700000020 | 1C470000002000000008 | 1C470000002000000008 | 1C470000002000000008 | 000041 | 41 | 0041 | 0E33 | 120F |
| a(61) | 1C47 | 1C4700000020 | 1C470000002000000002 | 1C470000002000000002 | 1C470000002000000002 | 000061 | 61 | 0041 | 0E33 | 120F |
| Ａ(EFBCA1) | 1C47 | 1C4700000020 | 1C470000002000000009 | 1C470000002000000008 | 1C470000002000000008 | 00FF21 | EFBCA1 | FF21 | 0E33 | 120F |
| ａ(EFBD81) | 1C47 | 1C4700000020 | 1C470000002000000003 | 1C470000002000000002 | 1C470000002000000002 | 00FF41 | EFBD81 | FF21 | 0E33 | 120F |
| あ(E38182) | 3D5A | 3D5A00000020 | 3D5A000000200000000E | 1FB6000000200000000E | 1FB6000000200000000E00000002 | 003042 | E38182 | 3042 | 1E52 | 2B15 |
| ぁ(E38181) | 3D5A | 3D5A00000020 | 3D5A000000200000000D | 1FB6000000200000000D | 1FB6000000200000000D00000002 | 003041 | E38181 | 3041 | 1E52 | 2B15 |
| ア(E382A2) | 3D5A | 3D5A00000020 | 3D5A0000002000000011 | 1FB6000000200000000E | 1FB6000000200000000E00000008 | 0030A2 | E382A2 | 30A2 | 1E52 | 2B15 |
| は(E381AF) | 3D74 | 3D7400000020 | 3D74000000200000000E | 1FD0000000200000000E | 1FD0000000200000000E00000002 | 00306F | E381AF | 306F | 1E6B | 2B2E |
| ば(E381B0) | 3D74 | 3D74000000200037 | 3D740000002000370000000E0002 | 1FD00000002000370000000E0002 | 1FD00000002000370000000E000200000002 | 003070 | E381B0 | 3070 | 1E6B | 2B2E |
| ぱ(E381B1) | 3D74 | 3D74000000200038 | 3D740000002000380000000E0002 | 1FD00000002000380000000E0002 | 1FD00000002000380000000E000200000002 | 003071 | E381B1 | 3071 | 1E6B | 2B2E |
| 1(31) | 1C3E | 1C3E00000020 | 1C3E0000002000000002 | 1C3E0000002000000002 | 1C3E0000002000000002 | 000031 | 31 | 0031 | 0E2A | 1206 |
| ①(E291A0) | 1C3E | 1C3E00000020 | 1C3E0000002000000006 | 1C3E0000002000000006 | 1C3E0000002000000006 | 002460 | E291A0 | 2460 | 0E2A | 1206 |
| 0(30) | 1C3D | 1C3D00000020 | 1C3D0000002000000002 | 1C3D0000002000000002 | 1C3D0000002000000002 | 000030 | 30 | 0030 | 0E29 | 1205 |
| 〇(E38087) | 1C3D | 1C3D00000020 | 1C3D0000002000000002 | 1C3D0000002000000002 | 1C3D0000002000000002 | 003007 | E38087 | 3007 | 0E29 | 1205 |
| 平成(E5B9B3E68890) | FB40DE73FB40E210 | FB40DE73FB40E210000000200020 | FB40DE73FB40E210000000200020000000020002 | 5E4E5A91000000200020000000020002 | 5E4E5A91000000200020000000020002 | 005E73006210 | E5B9B3E68890 | 5E736210 | FB40DE73FB40E210 | FB40DE73FB40E210 |
| ㍻(E38DBB) | FB40DE73FB40E210 | FB40DE73FB40E210000000200020 | FB40DE73FB40E2100000002000200000001C001C | FB40DE73FB40E2100000002000200000001C001C | FB40DE73FB40E2100000002000200000001C001C | 00337B | E38DBB | 337B | FB40DE73FB40E210 | FB40DE73FB40E210 |
| 🍣(F09F8DA3) | 130C | 130C00000020 | 130C0000002000000002 | 130C0000002000000002 | 130C0000002000000002 | 01F363 | F09F8DA3 | FFFD | FFFD | FBC3F363 |
| 🍺(F09F8DBA) | 1323 | 132300000020 | 13230000002000000002 | 13230000002000000002 | 13230000002000000002 | 01F37A | F09F8DBA | FFFD | FFFD | FBC3F37A |

どのCollationを使う？

どうなんでしょう？utf8mb4_ja_0900_as_cs_ksを選択するのが現状はよいのでしょうか？

もしくは、割り切ってutf8mb4_bin、utf8mb4_0900_binを選ぶんでしょうかね？

オマケ

最後に、上記のMarkdownを作成したプログラムを載せておきます。

実行すると、出力の一部にMarkdownが含まれたものが得られます。

$ python3 mysql_collation.py

比較するCollationや、文字の種類を変えてみるといろいろ試せるでしょう。

mysql_collation.py

import mysql.connector
from mysql.connector import MySQLConnection
from mysql.connector.cursor import MySQLCursor

connection_configuration: dict = {
    'user': 'kazuhira',
    'password': 'password',
    'host': '172.17.0.2',
    'database': 'practice'
}

collations = [
    'utf8mb4_0900_ai_ci',
    'utf8mb4_0900_as_ci',
    'utf8mb4_0900_as_cs',
    'utf8mb4_ja_0900_as_cs',
    'utf8mb4_ja_0900_as_cs_ks',
    'utf8mb4_bin',
    'utf8mb4_0900_bin',
    'utf8mb4_general_ci',
    'utf8mb4_unicode_ci',
    'utf8mb4_unicode_520_ci'
]

comparison_string_pairs = [
    ('A', 'a'),
    ('A', 'Ａ'),
    ('Ａ', 'ａ'),
    ('あ', 'ぁ'),
    ('あ', 'ア'),
    ('は', 'ば'),
    ('ば', 'ぱ'),
    ('1', '①'),
    ('0', '〇'),
    ('平成', '㍻'),
    ('🍣', '🍺')
]

try:
    with mysql.connector.connect(**connection_configuration) as conn:
        conn: MySQLConnection = conn

        with conn.cursor() as cur:
            cur: MySQLCursor = cur

            print('=====================================================')
            print('print utf8mb4 collations.')
            print('=====================================================')

            cur.execute("""
                 show collation
                 where
                    collation like 'utf8mb4_ja%' or
                    collation like 'utf8mb4_0900%' or
                    collation like 'utf8mb4%bin' or
                    collation like 'utf8mb4%general%' or
                    collation like 'utf8mb4%unicode%'
                    """)
            rows: list = cur.fetchall()

            sorted_collations = sorted(map(lambda r: r[0], rows), reverse=True)

            for c in sorted_collations:
                print(c)

            print()

            print('=====================================================')
            print('print strings equals comparison')
            print('=====================================================')

            print('| 比較 | ' + ' | '.join(collations) + ' |')
            print('|:----:|:----' + ':|:----'.join(list(map(lambda x: '', collations))) + ':|')

            for pair in comparison_string_pairs:
                print(f'| {pair[0]} = {pair[1]} ', end='')

                for collation in collations:
                    cur.execute("set names utf8mb4 collate %s", (collation,))
                    cur.execute("select case %s = %s when 1 then '○' else '×' end", (pair[0], pair[1]))
                    print(f' | {cur.fetchone()[0]}', end='')

                print(' |')

            print()

            print('=====================================================')
            print('print strings sort comparison')
            print('=====================================================')

            print('| 比較 | ' + ' | '.join(collations) + ' |')
            print('|:----:|:----' + ':|:----'.join(list(map(lambda x: '', collations))) + ':|')

            for pair in comparison_string_pairs:
                print(f'| {pair[0]} comp {pair[1]} ', end='')

                for collation in collations:
                    cur.execute("set names utf8mb4 collate %s", (collation,))
                    cur.execute("select %s > %s, %s < %s", (pair[0], pair[1], pair[0], pair[1]))
                    row = cur.fetchone()

                    if row[0] == 0 and row[1] == 0:
                        result = '='
                    elif row[0] == 1:
                        result = '>'
                    elif row[1] == 1:
                        result = '<'

                    print(f' | {result}', end='')

                print(' |')

            print()

            print('=====================================================')
            print('print strings weight')
            print('=====================================================')

            print('| 文字（hex） | ' + ' | '.join(map(lambda c: f'{c}（weight）', collations)) + ' |')
            print('|:----|:----' + '|:----'.join(list(map(lambda x: '', collations))) + '|')

            characters = []

            for pair in comparison_string_pairs:
                for s in pair:
                    if not s in characters:
                        characters.append(s)

            for c in characters:
                cur.execute('select hex(%s)', (c,))
                c_hex = cur.fetchone()[0]
                print(f'| {c}({c_hex})', end='')

                for collation in collations:
                    cur.execute("set names utf8mb4 collate %s", (collation,))
                    cur.execute("select hex(weight_string(%s))", (c,))
                    print(f' | {cur.fetchone()[0]}', end='')

                print(' |')

            print()

except mysql.connector.Error as err:
    print(f'VendorError: {err.errno}')
    print(f'SQLState: {err.sqlstate}')
    print(f'SQLException: {err.msg}')

Jackson Text Dataformats Moduleを使って、CSVファイルの読み書きをしてみる

これは、なにをしたくて書いたもの？

これまでCSVを読み書きするのに、OpenCSV、Super CSVなどを使ってきたのですが、JacksonでもCSVファイルの読み書きが
できることはなんとなく知っていたものの使ったことがありませんでした。

ちょっと試してみようかな、と思います。

どうやら速いみたいですし。

GitHub - uniVocity/csv-parsers-comparison: Comparisons among all Java-based CSV parsers in existence

Jackson Data Format Module

JacksonでCSVファイルを読み書きするモジュールは、Jackson Data Format Moduleのひとつになっています。GitHubリポジトリは、
こちらになります。

GitHub - FasterXML/jackson-dataformats-text: Uber-project for (some) standard Jackson textual format backends: csv, properties, yaml (xml to be added in future)

このリポジトリに含まれているモジュールでは、CSV、properties、toml（2.12.3から）、yamlに対応しています。

ドキュメントは、WikiやCSVモジュール内のREADME.mdを見ることになります。

Home · FasterXML/jackson-dataformats-text Wiki · GitHub

CsvSchema · FasterXML/jackson-dataformats-text Wiki · GitHub

https://github.com/FasterXML/jackson-dataformats-text/blob/jackson-dataformats-text-2.12.3/csv/README.md

あとは、Javadocですね。

Jackson-dataformat-CSV 2.12.3 API

DatabindとCoreにも依存しているので、こちらも見るとよいでしょう。

jackson-databind 2.12.3 API

Jackson-core 2.12.3 API

JacksonでCSVを読み書きする

Jacksonを使ってCSVファイルを読み書きするといっても、基本と成るのはJSONを扱う時に使っていたJacksonです。

CsvMapperというクラスをまずは使うことになるですが、こちらはObjectMapperのサブクラスだったりします。

CsvMapper (Jackson-dataformat-CSV 2.12.3 API)

実際のデータの読み書きに使うのも、Jackson Databindのクラスだったりします。

オブジェクト（POJO）のプロパティの設定に、@JsonFormatなどのアノテーションを使ったりするのも同じです。
JSONではないのですが。

このため、必然的にこのあたりの情報も見ていくことになるでしょう。

Home · FasterXML/jackson-databind Wiki · GitHub

Home · FasterXML/jackson-core Wiki · GitHub

あとは、特徴的なのがCsvSchemaですね。

CsvSchema (Jackson-dataformat-CSV 2.12.3 API)

こちらを使って、CSVのスキーマ定義を行います。スキーマ定義とは、CSVの読み書き時の設定に関する以下のような項目を
指しています。

• カラム定義（デフォルトは空）
• ヘッダーの有無（デフォルトはヘッダーなし）
• 囲み文字の定義（デフォルトは"）
• カラムの区切り文字（デフォルトは`,'）
• 配列要素を区切るための文字（デフォルトは:）
• 改行文字（デフォルトは\n）
  • CSVファイル作成の時のみ使う項目で、CSVパーサーは\r、\r\n、\nのいずれも扱える
• エスケープ文字（デフォルトなし）
  • CSVパーサーのみが使う項目で、CSVファイルの書き出し時は囲み文字を二重にして出力する
• 最初のレコードを無視するかどうか（デフォルトは無視しない）
• nullを表す文字列（デフォルトは空文字）
• ヘッダーレコードが存在する場合、スキーマ定義のカラム名がヘッダー名と一致する必要があるか（デフォルトは一致しなくてよい）

個人的には、エスケープ文字が読み込み時にしか効かないことに気づかなくて、けっこうハマりました…。

説明は、このくらいにしていくつかパターンを試していってみましょう。

お題

こんな感じでやってみます。

• CSVファイルの読み込み
  • 区切り文字,、囲み文字"、エスケープ文字\のCSVを読み込む
    • ヘッダー有り無しの2つのファイルを用意する
  • 読み込み結果は、Stringの配列、Map、自分で定義したクラス、の3つで扱う
• CSVファイルの書き込み
  • 区切り文字,、囲み文字"のCSVを出力する
    • ヘッダー有り無しの2つのパターンで出力する
  • 書き込みに使用するオブジェクトは、Stringの配列、自分で定義したクラス、の2つで扱う

読み込み時はMapを入れても扱いやすかったので入れましたが、書き込み時はくどくなるのでやめました…。

環境

今回の環境は、こちらです。

$ java --version
openjdk 11.0.11 2021-04-20
OpenJDK Runtime Environment (build 11.0.11+9-Ubuntu-0ubuntu2.20.04)
OpenJDK 64-Bit Server VM (build 11.0.11+9-Ubuntu-0ubuntu2.20.04, mixed mode, sharing)


$ mvn --version
Apache Maven 3.8.1 (05c21c65bdfed0f71a2f2ada8b84da59348c4c5d)
Maven home: $HOME/.sdkman/candidates/maven/current
Java version: 11.0.11, vendor: Ubuntu, runtime: /usr/lib/jvm/java-11-openjdk-amd64
Default locale: ja_JP, platform encoding: UTF-8
OS name: "linux", version: "5.4.0-72-generic", arch: "amd64", family: "unix"

Maven依存関係は、こちら。

    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-csv</artifactId>
            <version>2.12.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
            <version>2.12.3</version>
        </dependency>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.7.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.7.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
            </plugin>
        </plugins>
    </build>

まずはjackson-dataformat-csvが必要です。こちらで、jackson-databindおよびjackson-core、jackson-annotationsも
推移的に引き込まれます。

また、オブジェクトにマッピングする際にはLocalDateを使うことにしたので、jackson-datatype-jsr310も含めました。

GitHub - FasterXML/jackson-modules-java8: Set of support modules for Java 8 datatypes (Optionals, date/time) and features (parameter names)

動作確認は、テストコードを動かして行うことにしました。…アサーションはしませんでしたけど。

読み込み対象のCSVファイル

読み込み対象のCSVファイルは、こんな感じで用意しました。お題は書籍です。

ヘッダーあり。

src/test/resources/books.csv

isbn,title,price,publishDate
978-4621303252,Effective Java 第3版,"4400","2018-10-30"
978-4798151120,独習Java,3278,2019-05-15
978-4295008477,"新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト]",2860,2020-03-13
"978-4774189093","Java本格入門 \"モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで\"",3278,2017-04-18
978-4774166858,改訂2版 パーフェクトJava,3520,2014-11-01

ヘッダーなし。

src/test/resources/books_headerless.csv

978-4621303252,Effective Java 第3版,"4400","2018-10-30"
978-4798151120,独習Java,3278,2019-05-15
978-4295008477,"新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト]",2860,2020-03-13
"978-4774189093","Java本格入門 \"モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで\"",3278,2017-04-18
978-4774166858,改訂2版 パーフェクトJava,3520,2014-11-01

囲み文字の有無は、適当に仕込んでいます。

マッピング先のクラス

CSVファイルを読み込んだ内容を、自分で作ったオブジェクトにマッピングする場合のクラス。

src/test/java/org/littlewings/jackson/csv/Book.java

package org.littlewings.jackson.csv;

import java.time.LocalDate;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

@JsonPropertyOrder({"isbn", "title", "price", "publishDate"})  // for CsvMapper#schemaFor
public class Book {
    String isbn;
    String title;
    int price;
    @JsonFormat(pattern = "yyyy-MM-dd")
    LocalDate publishDate;

    public static Book create(String isbn, String title, int price, LocalDate publishDate) {
        Book book = new Book();

        book.setIsbn(isbn);
        book.setTitle(title);
        book.setPrice(price);
        book.setPublishDate(publishDate);

        return book;
    }

    // getter／setterは省略

}

ところどころJacksonのアノテーションが入っていますが、実際の利用時に紹介します。

CSVファイルを読み込む

まずは、CSVファイルを読み込んでみましょう。

テストコードの雛形。

src/test/java/org/littlewings/jackson/csv/JacksonCsvReadTest.java

package org.littlewings.jackson.csv;

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.fasterxml.jackson.databind.MappingIterator;
import com.fasterxml.jackson.dataformat.csv.CsvMapper;
import com.fasterxml.jackson.dataformat.csv.CsvParser;
import com.fasterxml.jackson.dataformat.csv.CsvSchema;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.junit.jupiter.api.Test;

public class JacksonCsvReadTest {
    // ここに、テストコードを書く
}

ここに、テストコードを埋めていく方針としましょう。アサーションしてませんけど…。

Stringの配列として読み込む（ヘッダーあり）

最初は、CSVファイルの各レコードをStringの配列として読み込みます。

ドキュメントだと、このあたりですね。

CsvSchema / Column definitions / "Unmapped" (no columns)

Data-binding without schema

こんな感じになりました。

    @Test
    public void readCsvWithHeaderAsStringArray() throws IOException {
        CsvMapper mapper = new CsvMapper();
        CsvSchema schema =
                CsvSchema
                        .emptySchema()
                        .withoutHeader()
                        .withSkipFirstDataRow(true)  // 1レコード目を飛ばす
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"')   // default
                        .withEscapeChar('\\');

        mapper.enable(CsvParser.Feature.WRAP_AS_ARRAY);

        try (BufferedReader reader = Files.newBufferedReader(Paths.get("src/test/resources/books.csv"), StandardCharsets.UTF_8)) {
            MappingIterator<String[]> iterator =
                    mapper
                            .readerFor(String[].class)
                            .with(schema)
                            .readValues(reader);

            while (iterator.hasNext()) {
                System.out.println(Arrays.stream(iterator.next()).collect(Collectors.joining(", ")));
            }
        }
    }

CsvMapperのインスタンスを作り、それからCsvSchemaの設定を行います。

        CsvMapper mapper = new CsvMapper();
        CsvSchema schema =
                CsvSchema
                        .emptySchema()
                        .withoutHeader()
                        .withSkipFirstDataRow(true)  // 1レコード目を飛ばす
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"')   // default
                        .withEscapeChar('\\');

        mapper.enable(CsvParser.Feature.WRAP_AS_ARRAY);

CsvSchema#emptySchemaでデフォルトのスキーマ定義が返るので、これをベースに必要に応じて設定を変えていきます。

読み込むCSVファイルはヘッダーありなのですが、ヘッダーの値を読んでもらっても困るので、ヘッダーなし、
最初のレコードを読み飛ばす設定にしました。

CsvParser.Feature.WRAP_AS_ARRAYは、レコードの構成要素を配列として返すので指定しています。その他、Listにする時などに
便利なようです。

CsvParser.Feature (Jackson-dataformat-CSV 2.12.3 API)

CSVファイルの読み込み、各レコードの取得はこんな感じになります。

        try (BufferedReader reader = Files.newBufferedReader(Paths.get("src/test/resources/books.csv"), StandardCharsets.UTF_8)) {
            MappingIterator<String[]> iterator =
                    mapper
                            .readerFor(String[].class)
                            .with(schema)
                            .readValues(reader);

            while (iterator.hasNext()) {
                System.out.println(Arrays.stream(iterator.next()).collect(Collectors.joining(", ")));
            }
        }

MappingIteratorは、Jackson Databindのクラスですね。

読み込み結果のClassクラス、スキーマ定義、CSVファイルの読み込み元を指定して、CsvMapperより取得します。

            MappingIterator<String[]> iterator =
                    mapper
                            .readerFor(String[].class)
                            .with(schema)
                            .readValues(reader);

こちらを使って、CSVファイルを1レコードずつ読んでいくようにしました。

実行結果。

978-4621303252, Effective Java 第3版, 4400, 2018-10-30
978-4798151120, 独習Java, 3278, 2019-05-15
978-4295008477, 新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト], 2860, 2020-03-13
978-4774189093, Java本格入門 "モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで", 3278, 2017-04-18
978-4774166858, 改訂2版 パーフェクトJava, 3520, 2014-11-01

Stringの配列として読み込む（ヘッダーなし）

ヘッダーなしのCSVファイルを読み込み、Stringの配列として受け取る場合。

    @Test
    public void readCsvWithoutHeaderAsStringArray() throws IOException {
        CsvMapper mapper = new CsvMapper();
        CsvSchema schema =
                CsvSchema
                        .emptySchema()
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"')   // default
                        .withEscapeChar('\\');

        mapper.enable(CsvParser.Feature.WRAP_AS_ARRAY);

        try (BufferedReader reader = Files.newBufferedReader(Paths.get("src/test/resources/books_headerless.csv"), StandardCharsets.UTF_8)) {
            MappingIterator<String[]> iterator =
                    mapper
                            .readerFor(String[].class)
                            .with(schema)
                            .readValues(reader);

            while (iterator.hasNext()) {
                System.out.println(Arrays.stream(iterator.next()).collect(Collectors.joining(", ")));
            }
        }
    }

先ほどとの違いは、ヘッダーなし、最初のレコードの読み飛ばしを消しただけですね。

そもそも、デフォルトがヘッダーなしなので…。

実行結果は、こちら。

978-4621303252, Effective Java 第3版, 4400, 2018-10-30
978-4798151120, 独習Java, 3278, 2019-05-15
978-4295008477, 新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト], 2860, 2020-03-13
978-4774189093, Java本格入門 "モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで", 3278, 2017-04-18
978-4774166858, 改訂2版 パーフェクトJava, 3520, 2014-11-01

Mapとして読み込む（ヘッダーあり）

次に、各レコードをMapとして読み込んでみましょう。こうすると、ヘッダーの内容をMapのキーとして扱ってくれます。

こちらの内容ですね。

With column names from first row

    @Test
    public void readCsvWithHeaderAsMap() throws IOException {
        CsvMapper mapper = new CsvMapper();
        CsvSchema schema =
                CsvSchema
                        .emptySchema()
                        .withHeader()  // 1レコード目をヘッダーとして使う
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"')   // default
                        .withEscapeChar('\\');

        try (BufferedReader reader = Files.newBufferedReader(Paths.get("src/test/resources/books.csv"), StandardCharsets.UTF_8)) {
            MappingIterator<Map<String, String>> iterator =
                    mapper
                            .readerFor(Map.class)
                            .with(schema)
                            .readValues(reader);

            while (iterator.hasNext()) {
                System.out.println(
                        iterator.next().entrySet().stream().map(e -> e.getKey() + ":" + e.getValue()).collect(Collectors.joining(", "))
                );
            }
        }
    }

なので、ヘッダーを認識するように設定。CsvParser.Feature.WRAP_AS_ARRAYは不要になります。

        CsvMapper mapper = new CsvMapper();
        CsvSchema schema =
                CsvSchema
                        .emptySchema()
                        .withHeader()  // 1レコード目をヘッダーとして使う
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"')   // default
                        .withEscapeChar('\\');

CsvMapper#readerForには、MapのClassクラスを指定。

            MappingIterator<Map<String, String>> iterator =
                    mapper
                            .readerFor(Map.class)
                            .with(schema)
                            .readValues(reader);

結果はこちら。

isbn:978-4621303252, title:Effective Java 第3版, price:4400, publishDate:2018-10-30
isbn:978-4798151120, title:独習Java, price:3278, publishDate:2019-05-15
isbn:978-4295008477, title:新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト], price:2860, publishDate:2020-03-13
isbn:978-4774189093, title:Java本格入門 "モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで", price:3278, publishDate:2017-04-18
isbn:978-4774166858, title:改訂2版 パーフェクトJava, price:3520, publishDate:2014-11-01

Mapとして読み込む（ヘッダーなし）

今度は、ヘッダーなしのCSVファイルを読み、Mapとして受け取ります。

    @Test
    public void readCsvWithoutHeaderAsMap() throws IOException {
        CsvMapper mapper = new CsvMapper();
        CsvSchema schema =
                CsvSchema
                        .builder()
                        .addColumns(List.of("isbn", "title", "price", "publishDate"), CsvSchema.ColumnType.STRING)  // カラムを定義
                        .setColumnSeparator(',')  // default
                        .setQuoteChar('"')  // default
                        .setEscapeChar('\\')
                        .build();

        try (BufferedReader reader = Files.newBufferedReader(Paths.get("src/test/resources/books_headerless.csv"), StandardCharsets.UTF_8)) {
            MappingIterator<Map<String, String>> iterator =
                    mapper
                            .readerFor(Map.class)
                            .with(schema)
                            .readValues(reader);

            while (iterator.hasNext()) {
                System.out.println(
                        iterator.next().entrySet().stream().map(e -> e.getKey() + ":" + e.getValue()).collect(Collectors.joining(", "))
                );
            }
        }
    }

変わったポイントとしては、CsvSchemaの作り方ですね。ヘッダーがないので、キーの名前をカラムとして定義する必要が
あります。

        CsvSchema schema =
                CsvSchema
                        .builder()
                        .addColumns(List.of("isbn", "title", "price", "publishDate"), CsvSchema.ColumnType.STRING)  // カラムを定義
                        .setColumnSeparator(',')  // default
                        .setQuoteChar('"')  // default
                        .setEscapeChar('\\')
                        .build();

変わったのは、ここくらいですね。

結果。

isbn:978-4621303252, title:Effective Java 第3版, price:4400, publishDate:2018-10-30
isbn:978-4798151120, title:独習Java, price:3278, publishDate:2019-05-15
isbn:978-4295008477, title:新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト], price:2860, publishDate:2020-03-13
isbn:978-4774189093, title:Java本格入門 "モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで", price:3278, publishDate:2017-04-18
isbn:978-4774166858, title:改訂2版 パーフェクトJava, price:3520, publishDate:2014-11-01

自分で定義したクラスで読み込む（ヘッダーあり）

読み込み系の最後は、自分で定義したクラスで読み込むようにしてみます。

ソースコードは、こんな感じに。

    @Test
    public void readCsvWithHeaderAsClass() throws IOException {
        CsvMapper mapper = new CsvMapper();
        mapper.registerModules(new JavaTimeModule());  // for LocalDate / LocalDateTime
        CsvSchema schema =
                mapper
                        .schemaFor(Book.class)
                        .withHeader()
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"')  // default
                        .withEscapeChar('\\');

        try (BufferedReader reader = Files.newBufferedReader(Paths.get("src/test/resources/books.csv"), StandardCharsets.UTF_8)) {
            MappingIterator<Book> iterator =
                    mapper
                            .readerFor(Book.class)
                            .with(schema)
                            .readValues(reader);

            while (iterator.hasNext()) {
                Book book = iterator.next();

                System.out.printf("isbn: %s, title: %s, price: %d, publishDate: %s%n", book.getIsbn(), book.getTitle(), book.getPrice(), book.getPublishDate());
            }
        }
    }

いきなり脱線しますが、マッピング先のクラスがこんな感じでLocalDateを使っているので

@JsonPropertyOrder({"isbn", "title", "price", "publishDate"})  // for CsvMapper#schemaFor
public class Book {
    String isbn;
    String title;
    int price;
    @JsonFormat(pattern = "yyyy-MM-dd")
    LocalDate publishDate;

CsvMapperにJavaTimeModuleを登録します。

        mapper.registerModules(new JavaTimeModule());  // for LocalDate / LocalDateTime

MappingIteratorあたりの使い方は変わりませんが、CsvSchemaの作り方が少し変わります。今回は、CsvMapper#schemaForを
使います。

        CsvSchema schema =
                mapper
                        .schemaFor(Book.class)
                        .withHeader()
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"')  // default
                        .withEscapeChar('\\');

これで指定したクラスがスキーマの元になるのですが、対象のクラスには@JsonPropertyOrderアノテーションで
プロパティの順を指定しておく必要があります。

@JsonPropertyOrder({"isbn", "title", "price", "publishDate"})  // for CsvMapper#schemaFor
public class Book {

注意点は、このくらいですね。

結果。

isbn: 978-4621303252, title: Effective Java 第3版, price: 4400, publishDate: 2018-10-30
isbn: 978-4798151120, title: 独習Java, price: 3278, publishDate: 2019-05-15
isbn: 978-4295008477, title: 新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト], price: 2860, publishDate: 2020-03-13
isbn: 978-4774189093, title: Java本格入門 "モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで", price: 3278, publishDate: 2017-04-18
isbn: 978-4774166858, title: 改訂2版 パーフェクトJava, price: 3520, publishDate: 2014-11-01

自分で定義したクラスで読み込む（ヘッダーなし）

ヘッダーなしの場合は、こちら。

    @Test
    public void readCsvWithoutHeaderAsClass() throws IOException {
        CsvMapper mapper = new CsvMapper();
        mapper.registerModules(new JavaTimeModule());  // for LocalDate / LocalDateTime
        CsvSchema schema =
                mapper
                        .schemaFor(Book.class)
                        .withoutHeader()
                        .withSkipFirstDataRow(true)  // 1レコード目を飛ばす
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"')  // default
                        .withEscapeChar('\\');

        try (BufferedReader reader = Files.newBufferedReader(Paths.get("src/test/resources/books.csv"), StandardCharsets.UTF_8)) {
            MappingIterator<Book> iterator =
                    mapper
                            .readerFor(Book.class)
                            .with(schema)
                            .readValues(reader);

            while (iterator.hasNext()) {
                Book book = iterator.next();

                System.out.printf("isbn: %s, title: %s, price: %d, publishDate: %s%n", book.getIsbn(), book.getTitle(), book.getPrice(), book.getPublishDate());
            }
        }
    }

あらためて説明しなおす内容はないので、割愛。

結果。

isbn: 978-4621303252, title: Effective Java 第3版, price: 4400, publishDate: 2018-10-30
isbn: 978-4798151120, title: 独習Java, price: 3278, publishDate: 2019-05-15
isbn: 978-4295008477, title: 新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト], price: 2860, publishDate: 2020-03-13
isbn: 978-4774189093, title: Java本格入門 "モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで", price: 3278, publishDate: 2017-04-18
isbn: 978-4774166858, title: 改訂2版 パーフェクトJava, price: 3520, publishDate: 2014-11-01

CSVファイルを書き込む

次は、CSVファイルの書き込みを行ってみましょう。

テストコードの雛形はこちら。

src/test/java/org/littlewings/jackson/csv/JacksonCsvWriteTest.java

package org.littlewings.jackson.csv;

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.util.List;

import com.fasterxml.jackson.databind.SequenceWriter;
import com.fasterxml.jackson.dataformat.csv.CsvMapper;
import com.fasterxml.jackson.dataformat.csv.CsvSchema;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.junit.jupiter.api.Test;

public class JacksonCsvWriteTest {
    String[][] booksArray = {
            {"978-4621303252", "Effective Java 第3版", "4400", "2018-10-30"},
            {"978-4798151120", "独習Java", "3278", "2019-05-15"},
            {"978-4295008477", "新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト]", "2860", "2020-03-13"},
            {"978-4774189093", "Java本格入門 \"モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで\"", "3278", "2017-04-18"},
            {"978-4774166858", "改訂2版 パーフェクトJava", "3520", "2014-11-01"}
    };

    List<Book> books =
            List.of(
                    Book.create("978-4621303252", "Effective Java 第3版", 4400, LocalDate.of(2018, 10, 30)),
                    Book.create("978-4798151120", "独習Java", 3278, LocalDate.of(2019, 5, 15)),
                    Book.create("978-4295008477", "新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト]", 2860, LocalDate.of(2020, 3, 13)),
                    Book.create("978-4774189093", "Java本格入門 \"モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで\"", 3278, LocalDate.of(2017, 4, 18)),
                    Book.create("978-4774166858", "改訂2版 パーフェクトJava", 3520, LocalDate.of(2014, 11, 1))
            );

    // ここに、テストを書く
}

CSVファイルに書き込む要素は、事前にフィールドに定義しておくことにしました。

では、各種コードを埋めていきます。

Stringの配列を書き込む（ヘッダーあり）

まずは、Stringの配列として書き込むパターンから。ヘッダーありです。

ソースコードは、こんな感じになりました。

    @Test
    public void writeCsvWithHeaderAsStringArray() throws IOException {
        CsvMapper mapper = new CsvMapper();
        CsvSchema schema =
                CsvSchema
                        .builder()
                        .addColumns(List.of("isbn", "title", "price", "publishDate"), CsvSchema.ColumnType.STRING)  // カラムを定義
                        .setUseHeader(true)  // print header
                        .setColumnSeparator(',')  // default
                        .setQuoteChar('"')  // default
                        .build();

        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("target/books_from_array.csv"), StandardCharsets.UTF_8)) {
            SequenceWriter sequenceWriter =
                    mapper
                            .writerFor(String[].class)
                            .with(schema)
                            .writeValues(writer);

            for (String[] values : booksArray) {
                sequenceWriter.write(values);
            }
        }
    }

CsvSchemaの作り方は読み込み時とそう変わりませんが、ヘッダーを作る分だけカラム定義が必要になります。

        CsvMapper mapper = new CsvMapper();
        CsvSchema schema =
                CsvSchema
                        .builder()
                        .addColumns(List.of("isbn", "title", "price", "publishDate"), CsvSchema.ColumnType.STRING)  // カラムを定義
                        .setUseHeader(true)  // print header
                        .setColumnSeparator(',')  // default
                        .setQuoteChar('"')  // default
                        .build();

また、CsvParser.Feature.WRAP_AS_ARRAYは不要です。

書き込みには、SequenceWriterを使い、1レコードずつ書き込んでいきます。

        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("target/books_from_array.csv"), StandardCharsets.UTF_8)) {
            SequenceWriter sequenceWriter =
                    mapper
                            .writerFor(String[].class)
                            .with(schema)
                            .writeValues(writer);

            for (String[] values : booksArray) {
                sequenceWriter.write(values);
            }
        }

結果はこちら。

target/books_from_array.csv

isbn,title,price,publishDate
978-4621303252,"Effective Java 第3版",4400,2018-10-30
978-4798151120,独習Java,3278,2019-05-15
978-4295008477,"新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト]",2860,2020-03-13
978-4774189093,"Java本格入門 ""モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで""",3278,2017-04-18
978-4774166858,"改訂2版 パーフェクトJava",3520,2014-11-01

ヘッダーも出力されています。

囲み文字のエスケープは、囲み文字を2つ重ねることで行います。読み込み時と違い、こちらは設定ができません。

Stringの配列を書き込む（ヘッダーなし）

ヘッダーなしの場合。

    @Test
    public void writeCsvWithoutHeaderAsStringArray() throws IOException {
        CsvMapper mapper = new CsvMapper();
        CsvSchema schema =
                CsvSchema
                        .emptySchema()
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"');  // default

        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("target/books_from_array_headerless.csv"), StandardCharsets.UTF_8)) {
            SequenceWriter sequenceWriter =
                    mapper
                            .writerFor(String[].class)
                            .with(schema)
                            .writeValues(writer);

            for (String[] values : booksArray) {
                sequenceWriter.write(values);
            }
        }
    }

ヘッダーがないので、すごくシンプルになります。

結果は、こちら。

target/books_from_array_headerless.csv

978-4621303252,"Effective Java 第3版",4400,2018-10-30
978-4798151120,独習Java,3278,2019-05-15
978-4295008477,"新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト]",2860,2020-03-13
978-4774189093,"Java本格入門 ""モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで""",3278,2017-04-18
978-4774166858,"改訂2版 パーフェクトJava",3520,2014-11-01

自分で定義したクラスで書き込む（ヘッダーあり）

最後は、自分で定義したクラスで書き込む場合です。まずは、ヘッダーありの場合から。

    @Test
    public void writeCsvWithHeaderAsClass() throws IOException {
        CsvMapper mapper = new CsvMapper();
        mapper.registerModules(new JavaTimeModule());  // for LocalDate / LocalDateTime
        CsvSchema schema =
                mapper
                        .schemaFor(Book.class)
                        .withHeader() // print header
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"');  // default

        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("target/books.csv"), StandardCharsets.UTF_8)) {
            SequenceWriter sequenceWriter =
                    mapper
                            .writerFor(Book.class)
                            .with(schema)
                            .writeValues(writer);

            for (Book book : books) {
                sequenceWriter.write(book);
            }
        }
    }

といっても、ここまで来ると本当に目新しい要素はないですね…。

読み込み時と同じく、CsvMapper#schemaForで対象のClassクラスを指定します。

        CsvSchema schema =
                mapper
                        .schemaFor(Book.class)
                        .withHeader() // print header
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"');  // default

結果。ヘッダーありです。

target/books.csv

isbn,title,price,publishDate
978-4621303252,"Effective Java 第3版",4400,2018-10-30
978-4798151120,独習Java,3278,2019-05-15
978-4295008477,"新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト]",2860,2020-03-13
978-4774189093,"Java本格入門 ""モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで""",3278,2017-04-18
978-4774166858,"改訂2版 パーフェクトJava",3520,2014-11-01

自分で定義したクラスで書き込む（ヘッダーなし）

ヘッダーなしの場合。さらっと。

    @Test
    public void writeCsvWithoutHeaderAsClass() throws IOException {
        CsvMapper mapper = new CsvMapper();
        mapper.registerModules(new JavaTimeModule());  // for LocalDate / LocalDateTime
        CsvSchema schema =
                mapper
                        .schemaFor(Book.class)
                        .withColumnSeparator(',')  // default
                        .withQuoteChar('"');  // default

        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("target/books_headerless.csv"), StandardCharsets.UTF_8)) {
            SequenceWriter sequenceWriter =
                    mapper
                            .writerFor(Book.class)
                            .with(schema)
                            .writeValues(writer);

            for (Book book : books) {
                sequenceWriter.write(book);
            }
        }
    }

結果。

target/books_headerless.csv

978-4621303252,"Effective Java 第3版",4400,2018-10-30
978-4798151120,独習Java,3278,2019-05-15
978-4295008477,"新世代Javaプログラミングガイド[Java SE 10/11/12/13と言語拡張プロジェクト]",2860,2020-03-13
978-4774189093,"Java本格入門 ""モダンスタイルによる基礎からオブジェクト指向・実用ライブラリまで""",3278,2017-04-18
978-4774166858,"改訂2版 パーフェクトJava",3520,2014-11-01

まとめ

Jackson Text Dataformats Moduleを使って、CSVファイルを読み書きしてみました。

Jacksonがベースになっているだけあって、他のCSV関係のライブラリとちょっと変わっている感じがしますが、高速なようですし
Jackson自体もよく使うと思うので、覚えておいてもよいでしょう。