Comment efficace d'insertion et de récupérer l'UUID dans la Base de Données

De les stocker dans une chaîne de caractères ASCII, et de rendre le champ de l'index.

MODIFIER

Egads, il m'est arrivé de faire un peu de fouiller le sujet, et suis tombé sur cette. Quel honteux de réponse. Je dois avoir été un peu à l'humeur de la journée. Si je pouvais, je venais de le supprimer et de déplacer sur. Cependant, ce n'est pas possible, je vais donc donner une capture d'une mise à jour.

Première, la seule façon de savoir ce qui est "efficace" est de mesurer, compte tenu du programme de temps et d'espace ainsi que le code source de complexité et de programmeur de l'effort.

Heureusement, celui-ci est assez facile.

J'ai écrit un très simple OSX application. Le modèle se compose d'un seul attribut: identifier.

Aucune de ces questions, si vous ne marquez pas votre attribut comme un indice. Il faudra beaucoup plus de temps lors de la création de la boutique, mais il va faire des requêtes beaucoup plus rapide.

Aussi, notez que la création d'un prédicat pour un attribut binaire est exactement la même que la création d'un pour une chaîne de caractères:

fetchRequest.predicate =
    [NSPredicate predicateWithFormat:@"identifier == %@", identifier];

L'application est très simple. Tout d'abord, il crée des N objets, et attribue un UUID à l'identifiant de l'attribut. Il enregistre le MOC tous les 500 objets. Nous avons ensuite stocker tous les identificateurs dans un tableau et de façon aléatoire shuffle. L'ensemble du CD de la pile est alors démolie complètement pour enlever tout ça de mémoire.

Ensuite, nous construisons la pile à nouveau, puis itérer sur les identifiants, et de faire une simple extraction. L'extraction de l'objet est construit, avec un prédicat simple pour extraire qu'un seul objet. Tout cela est fait à l'intérieur d'un autoreleasepool à garder chaque extraction aussi vierges que possible (je reconnais qu'il y aura une certaine interaction avec le CD caches). Ce n'est pas si important, que nous sommes tout juste en comparant les différentes techniques.

Binaire identifiant est de 16 octets pour l'UUID.

L'UUID de la Chaîne est de 36 octets de la chaîne, le résultat de l'appel [uuid UUIDString], et il ressemble à ceci (B85E91F3-4A0A-4ABB-A049-83B2A8E6085E).

Chaîne Base64 est un 24-octet string, le résultat de l'encodage base 64 16 octets UUID des données binaires, et il ressemble à ceci (uF6R80oKSrugSYOyqOYIXg==) pour le même UUID.

Est le nombre d'objets de cette exécution.

SQLite taille est la taille de la réelle fichier sqlite.

WAL taille est la taille du WAL (write-ahead d'enregistrement de fichier - juste pour info...

Créer est le nombre de secondes pour créer la base de données, y compris l'épargne.

Requête est le nombre de secondes à la requête de chaque objet.

Data Type     | Count (N) | SQLite Size | WAL Size  | Create  | Query
--------------+-----------+-------------+-----------+---------+---------
Binary        |   100,000 |   5,758,976 | 5,055,272 |  2.6013 |  9.2669
Binary        | 1,000,000 |  58,003,456 | 4,783,352 | 59.0179 | 96.1862
UUID String   |   100,000 |  10,481,664 | 4,148,872 |  3.6233 |  9.9160
UUID String   | 1,000,000 | 104,947,712 | 5,792,752 | 68.5746 | 93.7264
Base64 String |   100,000 |   7,741,440 | 5,603,232 |  3.0207 |  9.2446
Base64 String | 1,000,000 |  77,848,576 | 4,931,672 | 63.4510 | 94.5147

La première chose à noter ici est que la taille de base de données est beaucoup plus grande que les octets stockés (1 600 000 et 16 000 000 d') -, qui est attendue pour une base de données. Le montant de stockage supplémentaire sera un peu par rapport à la taille réelle de vos objets... ce ne stocke l'identifiant de sorte que le pourcentage des frais généraux sera plus élevé).

Deuxième, sur les problèmes de vitesse, de référence, en faisant de même 1 000 000 d'objet de la requête, mais à l'aide de l'objet-id dans le parcours a pris environ 82 secondes (noter la différence marquée entre ça et l'appel de existingObjectWithID:error: qui a eu un énorme 0.3065 secondes).

Vous devriez profil de votre propre base de données, y compris une utilisation judicieuse des instruments sur le code en cours d'exécution. J'imagine que les chiffres seraient quelque peu différente si je n'avais plusieurs pistes, mais ils sont tellement proches qu'il n'est pas nécessaire pour cette analyse.

Cependant, sur la base de ces chiffres, regardons les mesures de rendement pour l'exécution de code.

• Comme prévu, le stockage de la crue de l'UUID de données binaires est plus efficace en termes d'espace.
• Le temps de création est assez proche (la différence apparaissant à être basé sur le temps de créer des chaînes et de l'espace de stockage supplémentaire requis).
• De la requête semblent presque identiques, avec la chaîne binaire qui paraît être un tout petit peu plus lent. Je pense que c'était la préoccupation initiale -- en faisant une requête sur un attribut binaire.

Binaire gagne de l'espace par beaucoup, et il peut être considéré comme un proche appuient à la fois sur le temps de création de requête et de temps. Si l'on considère ceux, de stocker les données binaires est le gagnant clair.

Comment sur le code source de complexité et le temps du programmeur?

Bien, si vous utilisez une version moderne de l'iOS et OSX, il n'y a pratiquement pas de différence, surtout avec une simple catégorie sur NSUUID.

Cependant, il est une considération pour vous, et que la facilité d'utilisation des données dans la base de données. Lorsque vous stockez des données binaires, il est difficile d'obtenir une bonne vue sur les données.

Donc, si, pour une raison quelconque, vous voulez que les données dans la base de données d'être stockées de manière plus efficace pour les humains, puis les stocker comme une chaîne de caractères est un meilleur choix. Donc, vous pourriez envisager d'utiliser un encodage base64 (ou un autre encodage -- mais rappelez-vous qu'il est déjà dans la base,-256-codage).

FWIW, voici un exemple de la catégorie de faciliter l'accès à l'UUID à la fois comme NSData et base64 chaîne:

- (NSData*)data
{
    uuid_t rawuuid;
    [self getUUIDBytes:rawuuid];
    return [NSData dataWithBytes:rawuuid length:sizeof(rawuuid)];
}

- (NSString*)base64String
{
    uuid_t rawuuid;
    [self getUUIDBytes:rawuuid];
    NSData *data = [NSData dataWithBytesNoCopy:rawuuid length:sizeof(rawuuid) freeWhenDone:NO];
    return [data base64EncodedStringWithOptions:0];
}

- (instancetype)initWithBase64String:(NSString*)string
{
    NSData *data = [[NSData alloc] initWithBase64EncodedString:string options:0];
    if (data.length == sizeof(uuid_t)) {
        return [self initWithUUIDBytes:data.bytes];
    }
    return self = nil;
}

- (instancetype)initWithString:(NSString *)string
{
    if ((self = [self initWithUUIDString:string]) == nil) {
        self = [self initWithBase64String:string];
    }
    return self;
}

OriginalL'auteur Jody Hagins