L'insertion et la sélection des Uuid comme binaire(16)

Je ne comprends pas pourquoi

SELECT UUID();

Retourne quelque chose comme:

3f06af63-a93c-11e4-9797-00505690773f

Mais si je l'insère dans un fichier binaire(16) domaine (l'UUID ()), avec par exemple un AVANT déclencheur d'INSERTION et d'exécuter un select, il renvoie à quelque chose comme:

0782ef48-a439-11

Noter que ces deux Uuid ne sont pas les mêmes données.

Je me rends compte binaire et un UUID de la chaîne n'a pas l'air identiques, mais ne devrait pas les données sélectionnées au moins aussi longtemps? Sinon, comment peut-il être tout aussi susceptibles d'être unique?

Est-il préférable de le stocker en tant que char(36)? J'ai juste besoin d'être unique pour éviter de dupliquer les inserts. Il n'est jamais sélectionné ou utilisé pour les jointures.

EDIT:

avant de déclencher serait comme:

BEGIN

if NEW.UUID IS NULL THEN

NEW.UUID = UUID();

END IF

END

Montrez comment vous êtes en train de faire la INSERT.
BINARY(16) ne peut contenir 16 caractères. Donc, il contiendra les 16 premiers caractères de l'UUID que vous stockez.
Selon stackoverflow.com/questions/10950202/... ce n'est pas le cas. Aussi stackoverflow.com/questions/17726682/...
La réponse s'utilise UNHEX() pour convertir les UUID pour un certain nombre qui s'adapte à 16 octets.
Peu importe comment vous la faire tourner, ne serait-ce pas réduire la complexité d'environ 50%, alors? Cela m'a très confus.

OriginalL'auteur nickdnk | 2015-01-31

44

Donc, comme une réponse à des commentaires. La bonne façon de stocker une 36-char UUID comme binaire(16) est d'effectuer l'insertion d'une manière comme:
```
INSERT INTO sometable (UUID) VALUES
       (UNHEX(REPLACE("3f06af63-a93c-11e4-9797-00505690773f", "-","")))
```
UNHEX car un UUID est déjà un maléfice de la valeur. Nous trim (REPLACE) les tirets dans la déclaration d'apporter de la longueur jusqu'à 32 caractères ASCII (nos 16 octets représenté comme HEX). Vous pouvez le faire à tout moment avant de la stocker, de toute évidence, il n'a pas à être traitée par la base de données.

Vous pouvez récupérer l'UUID comme ceci:
```
SELECT HEX(UUID) FROM sometable;
```
Juste au cas où quelqu'un tombe sur ce fil et ne sait pas comment cela fonctionne.

Et n'oubliez pas: Si vous êtes à la sélection d'une ligne à l'aide de l'UUID, utilisation UNHEX() sur la condition:
```
SELECT * FROM sometable WHERE UUID = UNHEX('3f06af63a93c11e4979700505690773f');
```
Et pas HEX()sur la colonne:
```
SELECT * FROM sometable WHERE HEX(UUID) = '3f06af63a93c11e4979700505690773f';
```
La deuxième solution, même si elle fonctionne, exige que MySQL HEXes tous les Uuid avant de pouvoir déterminer les lignes de match. C'est très inefficace.

Edit: Si vous utilisez MySQL 8, vous devez avoir un coup d'oeil à l'UUID fonctions comme mentionné dans SlyDave de réponse. Cette réponse est toujours correct, mais il n'a pas d'optimiser les UUID des indices de ce qui peut être fait en natif à l'aide de ces fonctions.

OriginalL'auteur nickdnk
14

MySQL 8, vous pouvez utiliser deux nouveaux UUID fonctions:
- BIN_TO_UUID
```
SELECT BIN_TO_UUID(uuid, true) AS uuid FROM foo;
-- 3f06af63-a93c-11e4-9797-00505690773f
```
- UUID_TO_BIN
```
INSERT INTO foo (uuid) VALUES (UUID_TO_BIN('3f06af63-a93c-11e4-9797-00505690773f', true));
```
Cette méthode prend également en charge du réaménagement de la composante temporelle de l'uuid pour améliorer les performances de l'indexation (en le commandant par ordre chronologique), il suffit de définir le deuxième argument à true - cela ne fonctionne que pour UUID1.

Si vous utilisez le true sur UUID_TO_BIN drapeau pour les performances de l'indexation (recommandé), vous devez également définir sur BIN_TO_UUID sinon il ne sera pas convertir correctement.

Voir la documentation pour plus de détails.
- https://dev.mysql.com/doc/refman/8.0/en/miscellaneous-functions.html#function_uuid-to-bin
- http://mysqlserverteam.com/mysql-8-0-uuid-support/
Après beaucoup de recherches, nous avons décidé de migrer de MySQL vers PostgreSQL parce qu'ils ont un UUID type de données (tout comme incrément automatique, auto inserts et, plus important encore, vous pouvez simplement lire directement à l'aide d'une chaîne de caractères). Sinon, nous avons de revoir l'ensemble de notre base de code partout où nous avons une mise à jour ou lues à l'aide d'une pièce d'identité avec mysql 5.7 ou 8.
MySQL a un UUID() de la fonction pour un but spécifique. Alors que ce n'est pas un type de données, c'est l'équivalent en binaire(16) et génère insérez-friendly séquentielle (non aléatoire) Uuid.
Merci @nickdnk - mais en fin de compte, cela signifierait que nous venons de mettre à jour chacune de nos requêtes sur l'intégralité de notre base de code pour inclure cette fonction..
Ou vous pouvez utiliser un déclencheur, @friek108 🙂
Comment voulez-vous faire de la migration de MySQL vers PostgreSQL plus facile que de modifier le code de base pour les UUID des inserts? Je ne vois vraiment pas comment cela pourrait fonctionner. Pouvez-vous développer?

OriginalL'auteur SlyDave
3

Je suis à l'aide de MariaDB donc BIN_TO_UUID fonctions de la famille n'existent pas. J'ai réussi à obtenir les valeurs correspondantes de toute façon.

bin -> hex

Ici, uuid est le binaire(16) de la valeur d'un uuid, vous pourrez utiliser la valeur suivante pour SÉLECTIONNER une version lisible de.
```
LOWER(CONCAT(
    SUBSTR(HEX(uuid), 1, 8), '-',
    SUBSTR(HEX(uuid), 9, 4), '-',
    SUBSTR(HEX(uuid), 13, 4), '-',
    SUBSTR(HEX(uuid), 17, 4), '-',
    SUBSTR(HEX(uuid), 21)
))
```
hex -> bin

Ici, cc6e6d97-5501-11e7-b2cb-ceedca613421 est une version lisible de l'UUID, et vous pourrez utiliser la valeur ci-dessous dans une clause where à chercher pour cela.
```
UNHEX(REPLACE('cc6e6d97-5501-11e7-b2cb-ceedca613421', '-', ''))
```
Acclamations

Pourquoi ne pas simplement remplacer les tirets comme dans ma réponse? Quel est l'avantage de faire les 5 sous-chaîne d'appels?
Vous avez entièrement raison. Je ne sais pas non plus, à la tête du guidon, je suppose. Merci 🙂
Hehe. Ok. Je voudrais aussi faire à la chaîne concat trucs dans l'application de la couche de la place... il n'y a vraiment pas de raison de faire de la base de données n'cinq HEX() et SUBSTR() par UUID lorsque PHP, C#, java ou tout ce qui pourrait facilement insérer des tirets en divisant l'UUID. En fait, je ne travaille pas avec les tirets partout dans ma demande, car ils sont plus ou moins redondants.

OriginalL'auteur Alain Tiemblo
0

Les autres réponses sont correctes. Le UUID() fonction renvoie un 36 chaîne de caractères et qui doit être convertis en utilisant les fonctions affichées (UNHEX() ou, sur les nouvelles plates-formes, UUID_TO_BIN()).

Toutefois, si vous utilisez votre propre logiciel pour créer votre Uuid, vous pouvez utiliser le Hexadécimal Littérale notation à la place.

Donc je peut utiliser avec MySQL UUID() fonction:
```
INSERT INTO sometable (id) VALUES (UNHEX(REPLACE(UUID(), '-', '')));  -- all versions
INSERT INTO sometable (id) VALUES (UUID_TO_BIN(UUID());               -- since v8.0
```
Mais d'utiliser ce cas, je générer mon propre Uuid;
```
INSERT INTO sometable (id) VALUES 0x3f06af63a93c11e4979700505690773f;
```
De même, vous pouvez utiliser Hexadécimal Littéraux dans votre WHERE clauses:
```
SELECT * FROM sometable WHERE id = 0x3f06af63a93c11e4979700505690773f;
```
Ce sera plus rapide si vous n'avez pas à convertir vos données en l'UUID de la chaîne à chaque fois.

Remarque: le 'x' dans '0xaBc est sensible à la casse. Les chiffres hexadécimaux sont pas, cependant.

OriginalL'auteur Alexis Wilke

Vous devez vous connecter pour publier un commentaire.