Download uuid doctrine - download do código-fonte uuid doctrine

ramsey/uuid-doutrina

Use ramsey/uuid como tipo de campo do Doctrine

O pacote ramsey/uuid-doctrine fornece a capacidade de usar ramsey/uuid como um tipo de campo do Doctrine.

Este projeto segue um código de conduta. Ao participar deste projeto e de sua comunidade, espera-se que você defenda este código.

Instalação

Instale este pacote como uma dependência usando o Composer.

composer require ramsey/uuid-doctrine

Uso

Configuração

Para configurar o Doctrine para usar ramsey/uuid como tipo de campo, você precisará configurar o seguinte em seu bootstrap:

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

No Symfony:

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

No Zend Framework:

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

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

Em Laravel:

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

Na doutrina roave/psr-container:

 <?php
use Ramsey  Uuid  Doctrine  UuidType ;

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

Mapeamentos

Então, em seus modelos, você pode anotar propriedades definindo o tipo #[Column] como uuid e definindo um gerador personalizado de RamseyUuidUuidGenerator . A doutrina cuidará do 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 ;
    }
}

Se você usar o mapeamento XML em vez de atributos PHP.

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

Você também pode usar o mapeamento YAML.

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

Colunas de banco de dados binário

No exemplo anterior, o Doctrine criará uma coluna de banco de dados do tipo CHAR(36) se MariaDB/MySQL estiver em uso, mas você também pode usar esta biblioteca para armazenar UUIDs como strings binárias. O UuidBinaryType ajuda a fazer isso.

No seu bootstrap coloque o seguinte:

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

No Symfony:

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

Então, ao anotar as propriedades da classe do modelo, use uuid_binary em vez de uuid :

 #[Column(type: "uuid_binary")]

UUIDs binários otimizados para InnoDB - obsoletos

Mais adequado se você quiser usar UUIDs como chave primária. Observe que isso pode causar efeitos indesejados se:

decodificando bytes que não foram gerados usando este método
outro código (que não conhece este método) tenta decodificar os bytes resultantes

Mais informações neste artigo da Percona e UUID Talk de Ben Ramsey (começa no slide 58).

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

No 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

Então, em seus modelos, você pode anotar propriedades definindo o tipo @Column como uuid_binary_ordered_time e definindo um gerador personalizado de RamseyUuidUuidOrderedTimeGenerator . A doutrina cuidará do 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 ;
    }
}

Se você usar o mapeamento XML em vez de anotações PHP.

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

UUIDs binários otimizados para InnoDB - nova maneira

Com a introdução de novos tipos de UUID (incluindo UUID classificável e baseado em época unix versão 7), agora é recomendado usar uuid_binary regular com RamseyUuidDoctrineUuidV7Generator para chaves primárias.

No seu bootstrap coloque o seguinte:

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

No Symfony:

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

Então, em seus modelos, você pode anotar propriedades definindo o tipo #[Column] como uuid_binary e definindo um gerador personalizado de RamseyUuidUuidV7Generator . A doutrina cuidará do 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 ;
    }
}

Se você usar o mapeamento XML em vez de anotações PHP.

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

Considerações sobre PostgreSQL

Se você estiver usando PostgreSQL, o Doctrine usa uuid do PostgreSQL para RamseyUuidDoctrineUuidType ( uuid ). Portanto, você não precisa usar os tipos uuid_binary / uuid_binary_ordered_time ao usar o PostgreSQL. Você ainda pode usar UuidV7Generator::class para otimizar a indexação.

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

Trabalhando com identificadores binários

Ao trabalhar com identificadores binários você pode querer convertê-los em um formato legível. A partir do MySql 8.0 você pode usar as funções BIN_TO_UUID e UUID_TO_BIN documentadas aqui. O segundo argumento determina se a ordem dos bytes deve ser trocada, portanto ao usar uuid_binary você deve passar 0 e ao usar uuid_binary_ordered_time você deve passar 1.

Para outras versões você pode usar o seguinte:

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 ;

Testes:

 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)

Mais informações

Para obter mais informações sobre como começar a usar o Doctrine, confira o tutorial "Introdução ao Doctrine".

Contribuindo

Contribuições são bem-vindas! Para contribuir, familiarize-se com CONTRIBUTING.md.

Divulgação Coordenada

Manter as informações dos usuários seguras e protegidas é uma prioridade máxima e agradecemos a contribuição de pesquisadores de segurança externos. Se você acredita ter encontrado um problema de segurança no software mantido neste repositório, leia SECURITY.md para obter instruções sobre como enviar um relatório de vulnerabilidade.

ramsey/uuid-doutrine para empresas

Disponível como parte da assinatura Tidelift.

Os mantenedores do ramsey/uuid-doctrine e milhares de outros pacotes estão trabalhando com o Tidelift para fornecer suporte comercial e manutenção para os pacotes de código aberto que você usa para construir seus aplicativos. Economize tempo, reduza riscos e melhore a integridade do código, enquanto paga aos mantenedores dos pacotes exatos que você usa. Saber mais.