Descarga uuid doctrine - Descarga del código fuente uuid doctrine

ramsey/uuid-doctrina

Utilice ramsey/uuid como tipo de campo de Doctrina

El paquete ramsey/uuid-doctrine proporciona la posibilidad de utilizar ramsey/uuid como un tipo de campo Doctrine.

Este proyecto se adhiere a un código de conducta. Al participar en este proyecto y su comunidad, se espera que respete este código.

Instalación

Instale este paquete como una dependencia usando Composer.

composer require ramsey/uuid-doctrine

Uso

Configuración

Para configurar Doctrine para usar ramsey/uuid como tipo de campo, necesitarás configurar lo siguiente en tu bootstrap:

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

En Symfony:

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

En el marco Zend:

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

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

En Laravel:

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

En roave/psr-container-doctrine:

 <?php
use Ramsey  Uuid  Doctrine  UuidType ;

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

Mapeos

Luego, en sus modelos, puede anotar propiedades estableciendo el tipo #[Column] en uuid y definiendo un generador personalizado de RamseyUuidUuidGenerator . La doctrina se encargará del resto.

 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 utiliza el mapeo XML en lugar de los atributos PHP.

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

También puede utilizar el mapeo YAML.

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

Columnas de base de datos binaria

En el ejemplo anterior, Doctrine creará una columna de base de datos de tipo CHAR(36) si MariaDB/MySQL están en uso, pero también puedes usar esta biblioteca para almacenar UUID como cadenas binarias. UuidBinaryType ayuda a lograr esto.

En su bootstrap, coloque lo siguiente:

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

En Symfony:

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

Luego, al anotar propiedades de clase de modelo, use uuid_binary en lugar de uuid :

 #[Column(type: "uuid_binary")]

UUID binarios optimizados para InnoDB: en desuso

Más adecuado si desea utilizar UUID como clave principal. Tenga en cuenta que esto puede provocar efectos no deseados si:

bytes de decodificación que no se generaron utilizando este método
otro código (que no conoce este método) intenta decodificar los bytes resultantes

Más información en este artículo de Percona y UUID Talk de Ben Ramsey (comienza en la diapositiva 58).

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

En 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

Luego, en sus modelos, puede anotar propiedades estableciendo el tipo @Column en uuid_binary_ordered_time y definiendo un generador personalizado de RamseyUuidUuidOrderedTimeGenerator . La doctrina se encargará del resto.

#[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 utiliza el mapeo XML en lugar de anotaciones PHP.

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

UUID binarios optimizados para InnoDB: nueva forma

Con la introducción de nuevos tipos de UUID (incluido el UUID versión 7 ordenable y basado en la época de Unix), ahora se recomienda usar uuid_binary normal con RamseyUuidDoctrineUuidV7Generator para las claves primarias.

En su bootstrap, coloque lo siguiente:

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

En Symfony:

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

Luego, en sus modelos, puede anotar propiedades estableciendo el tipo #[Column] en uuid_binary y definiendo un generador personalizado de RamseyUuidUuidV7Generator . La doctrina se encargará del resto.

#[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 utiliza el mapeo XML en lugar de anotaciones PHP.

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

Consideraciones sobre PostgreSQL

Si estás usando PostgreSQL, Doctrine usa uuid de PostgreSQL para RamseyUuidDoctrineUuidType ( uuid ). Por lo tanto, no es necesario utilizar los tipos uuid_binary / uuid_binary_ordered_time cuando se utiliza PostgreSQL. Sin embargo, aún puedes usar UuidV7Generator::class para optimizar la indexación.

#[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 ;
    }
}

Trabajar con identificadores binarios

Cuando trabaje con identificadores binarios, es posible que desee convertirlos a un formato legible. A partir de MySql 8.0 puedes usar las funciones BIN_TO_UUID y UUID_TO_BIN documentadas aquí. El segundo argumento determina si el orden de los bytes debe intercambiarse, por lo tanto, cuando use uuid_binary debe pasar 0 y cuando use uuid_binary_ordered_time debe pasar 1.

Para otras versiones puedes usar lo siguiente:

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 ;

Pruebas:

 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)

Más información

Para obtener más información sobre cómo empezar a utilizar Doctrine, consulta el tutorial "Introducción a Doctrine".

Contribuyendo

¡Las contribuciones son bienvenidas! Para contribuir, familiarícese con CONTRIBUTING.md.

Divulgación coordinada

Mantener la información del usuario segura y protegida es una prioridad absoluta y agradecemos la contribución de investigadores de seguridad externos. Si cree que ha encontrado un problema de seguridad en el software que se mantiene en este repositorio, lea SECURITY.md para obtener instrucciones sobre cómo enviar un informe de vulnerabilidad.

ramsey/uuid-doctrina para empresas

Disponible como parte de la suscripción Tidelift.

Los mantenedores de ramsey/uuid-doctrine y miles de otros paquetes están trabajando con Tidelift para brindar soporte comercial y mantenimiento para los paquetes de código abierto que utiliza para crear sus aplicaciones. Ahorre tiempo, reduzca el riesgo y mejore la salud del código, mientras paga a los encargados del mantenimiento de los paquetes exactos que utiliza. Obtenga más información.