uuid doctrine Télécharger - uuid doctrine Téléchargement du code source

ramsey/uuid-doctrine

Utilisez ramsey/uuid comme type de champ Doctrine

Le package ramsey/uuid-doctrine offre la possibilité d'utiliser ramsey/uuid comme type de champ Doctrine.

Ce projet adhère à un code de conduite. En participant à ce projet et à sa communauté, vous êtes censé respecter ce code.

Installation

Installez ce package en tant que dépendance à l'aide de Composer.

composer require ramsey/uuid-doctrine

Usage

Configuration

Pour configurer Doctrine pour utiliser ramsey/uuid comme type de champ, vous devrez configurer les éléments suivants dans votre bootstrap :

 Doctrine  DBAL  Types Type:: addType ( ' uuid ' , ' RamseyUuidDoctrineUuidType ' );

Dans Symfony :

 # config/packages/doctrine.yaml
doctrine :
    dbal :
        types :
            uuid : RamseyUuidDoctrineUuidType

Dans Zend Framework :

 <?php
// module . config . php
use Ramsey  Uuid  Doctrine  UuidType ;

return [
    ' doctrine ' => [
        ' configuration ' => [
            ' orm_default ' => [
                ' types ' => [
                    UuidType:: NAME => UuidType::class,

Dans Laravel :

 <?php
// config / doctrine . php
    ' custom_types '               => [
         Ramsey  Uuid  Doctrine UuidType:: NAME =>  Ramsey  Uuid  Doctrine UuidType::class
    ],

Dans roave/psr-container-doctrine :

 <?php
use Ramsey  Uuid  Doctrine  UuidType ;

return [
    ' doctrine ' => [
        ' types ' => [
            UuidType:: NAME => UuidType::class,
        ],
        /* ... */
    ],
    /* ... */
];

Mappages

Ensuite, dans vos modèles, vous pouvez annoter les propriétés en définissant le type #[Column] sur uuid et en définissant un générateur personnalisé de RamseyUuidUuidGenerator . La doctrine s’occupera du reste.

 use Doctrine  ORM  Mapping as ORM ;
use Ramsey  Uuid  Doctrine  UuidGenerator ;
use Ramsey  Uuid  UuidInterface ;


#[ ORM Entity]
#[ ORM Table(name: " products " )]
class Product
{
    #[ ORM Id]
    #[ ORM Column(type: " uuid " , unique: true )]
    #[ ORM GeneratedValue(strategy: " CUSTOM " )]
    #[ ORM CustomIdGenerator(class: UuidGenerator::class)]
    protected UuidInterface $ id ;

    public function getId (): UuidInterface
    {
        return $ this -> id ;
    }
}

Si vous utilisez le mappage XML au lieu des attributs PHP.

< id name = " id " column = " id " type = " uuid " >
    < generator strategy = " CUSTOM " />
    < custom-id-generator class = " RamseyUuidDoctrineUuidGenerator " />
</ id >

Vous pouvez également utiliser le mappage YAML.

 id :
    id :
        type : uuid
        generator :
            strategy : CUSTOM
        customIdGenerator :
            class : RamseyUuidDoctrineUuidGenerator

Colonnes de base de données binaires

Dans l'exemple précédent, Doctrine créera une colonne de base de données de type CHAR(36) si MariaDB / MySQL est utilisée, mais vous pouvez également utiliser cette bibliothèque pour stocker les UUID sous forme de chaînes binaires. Le UuidBinaryType permet d'accomplir cela.

Dans votre bootstrap, placez ce qui suit :

 Doctrine  DBAL  Types Type:: addType ( ' uuid_binary ' , ' RamseyUuidDoctrineUuidBinaryType ' );
$ entityManager -> getConnection ()-> getDatabasePlatform ()-> registerDoctrineTypeMapping ( ' uuid_binary ' , ' binary ' );

Dans Symfony :

 # config/packages/doctrine.yaml
doctrine :
    dbal :
        types :
            uuid_binary :  RamseyUuidDoctrineUuidBinaryType
# Uncomment if using doctrine/orm <2.8
        # mapping_types:
            # uuid_binary: binary

Ensuite, lors de l'annotation des propriétés de classe de modèle, utilisez uuid_binary au lieu de uuid :

 #[Column(type: "uuid_binary")]

UUID binaires optimisés pour InnoDB - obsolètes

Plus approprié si vous souhaitez utiliser des UUID comme clé primaire. Notez que cela peut provoquer des effets inattendus si :

décodage des octets qui n'ont pas été générés à l'aide de cette méthode
un autre code (qui ne connaît pas cette méthode) tente de décoder les octets résultants

Plus d'informations dans cet article Percona et UUID Talk de Ben Ramsey (commence à la diapositive 58).

 Doctrine  DBAL  Types Type:: addType ( ' uuid_binary_ordered_time ' , ' RamseyUuidDoctrineUuidBinaryOrderedTimeType ' );
$ entityManager -> getConnection ()-> getDatabasePlatform ()-> registerDoctrineTypeMapping ( ' uuid_binary_ordered_time ' , ' binary ' );

Dans Symfony :

 # config/packages/doctrine.yaml
doctrine :
   dbal :
       types :
           uuid_binary_ordered_time : RamseyUuidDoctrineUuidBinaryOrderedTimeType
# Uncomment if using doctrine/orm <2.8
       # mapping_types:
           # uuid_binary_ordered_time: binary

Ensuite, dans vos modèles, vous pouvez annoter les propriétés en définissant le type @Column sur uuid_binary_ordered_time et en définissant un générateur personnalisé de RamseyUuidUuidOrderedTimeGenerator . La doctrine s’occupera du reste.

#[Entity]
#[Table(name: " products " )]´
class Product
{
    #[Id]
    #[Column(type: " uuid_binary_ordered_time " , unique: true )]
    #[GeneratedValue(strategy: " CUSTOM " )]
    #[CustomIdGenerator(class: UuidOrderedTimeGenerator::class)]
    protected UuidInterface $ id ;

    public function getId (): UuidInterface
    {
        return $ this -> id ;
    }
}

Si vous utilisez le mappage XML au lieu des annotations PHP.

< id name = " id " column = " id " type = " uuid_binary_ordered_time " >
    < generator strategy = " CUSTOM " />
    < custom-id-generator class = " RamseyUuidDoctrineUuidOrderedTimeGenerator " />
</ id >

UUID binaires optimisés pour InnoDB - nouvelle méthode

Avec l'introduction de nouveaux types d'UUID (y compris la version 7 de l'UUID triable basé sur l'époque Unix), il est désormais recommandé d'utiliser uuid_binary standard avec RamseyUuidDoctrineUuidV7Generator pour les clés primaires.

Dans votre bootstrap, placez ce qui suit :

 Doctrine  DBAL  Types Type:: addType ( ' uuid_binary ' , ' RamseyUuidDoctrineUuidBinaryType ' );
$ entityManager -> getConnection ()-> getDatabasePlatform ()-> registerDoctrineTypeMapping ( ' uuid_binary ' , ' binary ' );

Dans Symfony :

 # config/packages/doctrine.yaml
doctrine :
    dbal :
        types :
            uuid_binary :  RamseyUuidDoctrineUuidBinaryType
# Uncomment if using doctrine/orm <2.8
        # mapping_types:
            # uuid_binary: binary

Ensuite, dans vos modèles, vous pouvez annoter les propriétés en définissant le type #[Column] sur uuid_binary et en définissant un générateur personnalisé de RamseyUuidUuidV7Generator . La doctrine s’occupera du reste.

#[Entity]
#[Table(name: " products " )]
class Product
{
    #[Id]
    #[Column(type: " uuid_binary " , unique: true )]
    #[GeneratedValue(strategy: " CUSTOM " )]
    #[CustomIdGenerator(class: UuidV7Generator::class)]
    protected UuidInterface $ id ;

    public function getId (): UuidInterface
    {
        return $ this -> id ;
    }
}

Si vous utilisez le mappage XML au lieu des annotations PHP.

< id name = " id " column = " id " type = " uuid_binary " >
    < generator strategy = " CUSTOM " />
    < custom-id-generator class = " RamseyUuidDoctrineUuidV7Generator " />
</ id >

Considérations sur PostgreSQL

Si vous utilisez PostgreSQL, Doctrine utilise uuid de PostgreSQL pour le RamseyUuidDoctrineUuidType ( uuid ). Par conséquent, vous n'avez pas besoin d'utiliser les types uuid_binary / uuid_binary_ordered_time lorsque vous utilisez PostgreSQL. Vous pouvez cependant toujours utiliser UuidV7Generator::class pour optimiser l'indexation.

#[Entity]
#[Table(name: " products " )]
class Product
{
    #[Id]
    #[Column(type: " uuid " , unique: true )]
    #[GeneratedValue(strategy: " CUSTOM " )]
    #[CustomIdGenerator(class: UuidV7Generator::class)]
    protected UuidInterface $ id ;

    public function getId (): UuidInterface
    {
        return $ this -> id ;
    }
}

Travailler avec des identifiants binaires

Lorsque vous travaillez avec des identifiants binaires, vous souhaiterez peut-être les convertir dans un format lisible. Depuis MySql 8.0, vous pouvez utiliser les fonctions BIN_TO_UUID et UUID_TO_BIN documentées ici. Le deuxième argument détermine si l'ordre des octets doit être inversé, donc lorsque vous utilisez uuid_binary vous devez transmettre 0 et lorsque vous utilisez uuid_binary_ordered_time vous devez transmettre 1.

Pour les autres versions, vous pouvez utiliser ce qui suit :

DELIMITER $$

CREATE
    FUNCTION BIN_TO_UUID(bin_uuid BINARY( 16 ), swap_flag BOOLEAN )
    RETURNS CHAR ( 36 )
    DETERMINISTIC
    BEGIN
       DECLARE hex_uuid CHAR ( 32 );
       SET hex_uuid = HEX(bin_uuid);
       RETURN LOWER (CONCAT(
            IF(swap_flag, SUBSTR(hex_uuid, 9 , 8 ),SUBSTR(hex_uuid, 1 , 8 )), ' - ' ,
            IF(swap_flag, SUBSTR(hex_uuid, 5 , 4 ),SUBSTR(hex_uuid, 9 , 4 )), ' - ' ,
            IF(swap_flag, SUBSTR(hex_uuid, 1 , 4 ),SUBSTR(hex_uuid, 13 , 4 )), ' - ' ,
            SUBSTR(hex_uuid, 17 , 4 ), ' - ' ,
            SUBSTR(hex_uuid, 21 )
        ));
    END$$


CREATE
    FUNCTION UUID_TO_BIN(str_uuid CHAR ( 36 ), swap_flag BOOLEAN )
    RETURNS BINARY( 16 )
    DETERMINISTIC
    BEGIN
      RETURN UNHEX(CONCAT(
          IF(swap_flag, SUBSTR(str_uuid, 15 , 4 ),SUBSTR(str_uuid, 1 , 8 )),
          SUBSTR(str_uuid, 10 , 4 ),
          IF(swap_flag, SUBSTR(str_uuid, 1 , 8 ),SUBSTR(str_uuid, 15 , 4 )),
          SUBSTR(str_uuid, 20 , 4 ),
          SUBSTR(str_uuid, 25 ))
      );
    END$$

DELIMITER ;

Essais :

 mysql> select '07a2f327-103a-11e9-8025-00ff5d11a779' as uuid, BIN_TO_UUID(UUID_TO_BIN('07a2f327-103a-11e9-8025-00ff5d11a779', 0), 0) as flip_flop;
+--------------------------------------+--------------------------------------+
| uuid                                 | flip_flop                            |
+--------------------------------------+--------------------------------------+
| 07a2f327-103a-11e9-8025-00ff5d11a779 | 07a2f327-103a-11e9-8025-00ff5d11a779 |
+--------------------------------------+--------------------------------------+
1 row in set (0.00 sec)

mysql> select '07a2f327-103a-11e9-8025-00ff5d11a779' as uuid, BIN_TO_UUID(UUID_TO_BIN('07a2f327-103a-11e9-8025-00ff5d11a779', 1), 1) as flip_flop;
+--------------------------------------+--------------------------------------+
| uuid                                 | flip_flop                            |
+--------------------------------------+--------------------------------------+
| 07a2f327-103a-11e9-8025-00ff5d11a779 | 07a2f327-103a-11e9-8025-00ff5d11a779 |
+--------------------------------------+--------------------------------------+
1 row in set (0.00 sec)

Plus d'informations

Pour plus d'informations sur la prise en main de Doctrine, consultez le didacticiel « Prise en main de Doctrine ».

Contribuer

Les contributions sont les bienvenues ! Pour contribuer, veuillez vous familiariser avec CONTRIBUTING.md.

Divulgation coordonnée

Assurer la sécurité des informations des utilisateurs est une priorité absolue, et nous apprécions la contribution de chercheurs externes en sécurité. Si vous pensez avoir trouvé un problème de sécurité dans un logiciel conservé dans ce référentiel, veuillez lire SECURITY.md pour obtenir des instructions sur la soumission d'un rapport de vulnérabilité.

ramsey/uuid-doctrine pour l'entreprise

Disponible dans le cadre de l’abonnement Tidelift.

Les responsables de ramsey/uuid-doctrine et de milliers d'autres packages travaillent avec Tidelift pour fournir un support commercial et une maintenance pour les packages open source que vous utilisez pour créer vos applications. Gagnez du temps, réduisez les risques et améliorez la santé du code, tout en payant les responsables des packages exacts que vous utilisez. Apprendre encore plus.