[JAVA] Enregistrer les données UUID dans MySQL sous 16 octets

Il y a des histoires similaires dans divers endroits, mais je les écrirai pour ma propre compréhension et mémorandum.

À propos de l'UUID

https://ja.wikipedia.org/wiki/UUID

L'occurrence d'origine est visible sur Wikipedia, etc., et en fonctionnement réel, elle est souvent utilisée lors de l'attribution d'un identifiant unique aux données pendant le développement.

Il existe plusieurs versions d'UUID, celle qui semble être la plus utilisée dans le développement est ** UUID version 4 (générée aléatoirement) **, et l'autre ** version 1 (générée à l'aide de l'adresse Mac et des informations d'horodatage). ** etc.

La largeur en bits est de ** 128 bits (16 octets) ** et elle est exprimée en notation hexadécimale comme suit. (32 octets + 4 octets de limite = 36 octets. "-" Est la chaîne de caractères de limite)

550e8400-e29b-41d4-a716-446655440000

Enregistrer sur MySQL avec 16 octets en utilisant SQL (8.0 et versions antérieures)

Lors de l'enregistrement sur MySQL avec 16 octets, l'UUID de la représentation de chaîne hexadécimale moins la chaîne de limite est converti en binaire et enregistré. Exprimé en SQL, cela ressemble à ceci:

CREATE TABLE `sada ` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `UUID VARBINARY(16) NOT NULL,
  `name` VARCHAR(1024) NOT NULL,
  PRIMARY KEY (`id`)
)
  ENGINE = InnoDB,
  CHARACTER SET = `utf8mb4`, COLLATE = `utf8mb4_bin`;

INSERT INTO sada (
    uuid,
    name
)
VALUES(
    UNHEX(REPLACE('550e8400-e29b-41d4-a716-446655440000', '-', '')),
    'masashi'
);

Enregistrer sur MySQL avec 16 octets en utilisant SQL (8.0 ou version ultérieure)

À partir de MySQL 8, des fonctions de manipulation des UUID ont été ajoutées. Si vous utilisez 8 ou une version ultérieure, vous pouvez l'utiliser pour vous débarrasser du traitement d'origine qui vous rend confus.

https://mysqlserverteam.com/mysql-8-0-uuid-support/

--UUID_TO_BIN (Convertir la chaîne UUID en binaire) --BIN_TO_UUID (Convertir le binaire en chaîne UUID)

L'exemple cite le blog officiel ci-dessus.

CREATE TABLE t (id binary(16) PRIMARY KEY);

INSERT INTO t VALUES(UUID_TO_BIN(UUID()));
Query OK, 1 row affected (0,00 sec)

#a few inserts later..

SELECT BIN_TO_UUID(id) FROM t;
+--------------------------------------+
| BIN_TO_UUID(id); |
+--------------------------------------+
| 586bcc2d-9a96-11e6-852c-4439c456d444 |
| 5942e49a-9a96-11e6-852c-4439c456d444 |
| 841ae775-9a96-11e6-852c-4439c456d444 |
| 84393c8e-9a96-11e6-852c-4439c456d444 |
| af0f27e2-9aad-11e6-852c-4439c456d444 |
+--------------------------------------+
5 rows in set (0,00 sec)

Enregistrer sur MySQL avec 16 octets en utilisant Java / Kotlin

Les informations UUID générées dans chaque langue peuvent être stockées dans 16 octets par binaire à partir du programme.

Seul l'exemple de Kotlin est montré ici. Étant donné que la classe UUID existe dans Java / Kotlin, c'est OK si vous créez la logique de conversion de type UUID-> Byte array et Byte array-> UUID type comme indiqué ci-dessous et l'incorporer en fonction de l'environnement (ORM etc.) à utiliser. est.

    fun uuidToBytes(uuid: UUID): ByteArray {
        val buffer = ByteBuffer.allocate(16)
        buffer.putLong(uuid.mostSignificantBits)
        buffer.putLong(uuid.leastSignificantBits)
        return buffer.array()
    }

    fun bytesToUuid(bytes: ByteArray?): UUID? {
        if (bytes == null) {
            return null
        }
        val buffer = ByteBuffer.wrap(bytes)
        return UUID(buffer.long, buffer.long)
    }

Annexe. Représentation d'identité plus petite

Étant donné que l'UUID est une représentation d'identifiant assez grande avec 16 octets, je pense qu'il existe un moyen d'adopter un identifiant plus grand au lieu d'essayer de gagner de la taille en enregistrant l'UUID. Ce qui suit est pour référence seulement.

[À propos du générateur d'ID basé sur le temps léger "shakeflake (nom provisoire)"](https://developer.smartnews.com/blog/2013/07/31/shakeflake-is-a-tool-for-generating-unique- numéros d'identification /)