Ilustração mostrando um laptop e arquivos de caixa de documentos acima dele
Stokkete/Shutterstock.com

Um Identificador Único Universal (UUID) é uma forma específica de identificador que pode ser considerado único com segurança para a maioria dos propósitos práticos. Dois UUIDs gerados corretamente têm uma chance praticamente insignificante de serem idênticos, mesmo que sejam criados em dois ambientes diferentes por partes separadas. É por isso que se diz que os UUIDs são universalmente único.

Neste artigo, veremos as características dos UUIDs, como sua exclusividade funciona e os cenários em que eles podem simplificar a identificação de recursos. Embora abordemos os UUIDs da perspectiva comum do software que interage com os registros do banco de dados, eles são amplamente aplicáveis ​​a qualquer caso de uso em que seja necessária a geração descentralizada de ID exclusivo.

O que realmente é um UUID?

Um UUID é simplesmente um valor que você pode tratar com segurança como único. O risco de colisão é tão baixo que você pode optar por ignorá-lo completamente. Você pode ver UUIDs referidos usando termos diferentes (GUID, ou Globally Unique Identifier, é a semântica preferida da Microsoft), mas o significado e o efeito permanecem os mesmos.

Um UUID verdadeiro é um identificador exclusivo gerado e representado por um formato padronizado. UUIDs válidos são definidos pela RFC 4122; esta especificação descreve os algoritmos que podem ser usados ​​para gerar UUIDs que preservam a exclusividade nas implementações, sem uma autoridade central de emissão.

O RFC inclui cinco algoritmos diferentes, cada um usando um mecanismo diferente para produzir um valor. Aqui está um breve resumo das “versões” disponíveis:

  • Versão 1 - Com base no tempo – Combina um carimbo de data/hora, uma sequência de relógio e um valor específico para o dispositivo gerador (geralmente seu endereço MAC) para produzir uma saída exclusiva para esse host naquele momento.
  • Versão 2 – Segurança DCE – Esta versão foi desenvolvida como uma evolução da Versão 1 para uso com o Distributed Computing Environment (DCE). Não é amplamente utilizado.
  • Versão 3 – Baseado em Nome (MD5) – MD5 hashes um “namespace” e um “name” para criar um valor exclusivo para esse nome dentro do namespace. A geração de outro UUID com o mesmo namespace e nome produzirá uma saída idêntica para que esse método forneça resultados reproduzíveis.
  • Versão 4 – Aleatório – A maioria dos sistemas modernos tende a optar pelo UUID v4, pois usa a fonte de números aleatórios ou pseudo-aleatórios do host para emitir seus valores. As chances de o mesmo UUID ser produzido duas vezes são praticamente insignificantes.
  • Versão 5 – Baseado em Nome (SHA-1) – Isso é semelhante à versão 3, mas usa o algoritmo SHA-1 mais forte para fazer hash do namespace e do nome de entrada.

Embora a RFC se refira aos algoritmos como versões, isso não significa que você deva sempre usar a Versão 5 porque ela é aparentemente a mais nova. A escolha depende do seu caso de uso; em muitos cenários, a v4 é escolhida devido à sua natureza aleatória. Isso o torna o candidato ideal para cenários simples de “me dê um novo identificador”.

Os algoritmos de geração emitem um inteiro sem sinal de 128 bits. No entanto, os UUIDs são mais comumente vistos como strings hexadecimais e também podem ser armazenados como uma sequência binária de 16 caracteres. Aqui está um exemplo de uma string UUID:

16763be4-6022-406e-a950-fcd5018633ca

O valor é representado como cinco grupos de caracteres alfanuméricos separados por caracteres de traço. Os traços não são um componente obrigatório da string; sua presença se deve a detalhes históricos da especificação UUID. Eles também tornam o identificador muito mais fácil para os olhos humanos perceberem.

Casos de uso de UUID

O principal caso de uso para UUIDs é a geração descentralizada de identificadores exclusivos. Você pode gerar o UUID em qualquer lugar e considerá-lo exclusivo com segurança, seja ele originado de seu código de back-end, um dispositivo cliente ou seu mecanismo de banco de dados.

Os UUIDs simplificam a determinação e a manutenção da identidade do objeto em ambientes desconectados. Historicamente, a maioria dos aplicativos usava um campo inteiro com incremento automático como chave primária. Ao criar um novo objeto, você não pode saber seu ID até depois de ele foi inserido no banco de dados. Os UUIDs permitem determinar a identidade muito mais cedo em seu aplicativo.

Aqui está uma demonstração básica do PHP que demonstra a diferença. Vejamos primeiro o sistema baseado em números inteiros:

class BlogPost { public function __construct( public readonly ?int $Id, public readonly string $Headline, public readonly ?AuthorCollection $Authors=null) {} }   #[POST("/posts")] function createBlogPost(HttpRequest $Request) : void { $headline = $Request -> getField("Headline"); $blogPost = new BlogPost(null, $headline); }

Temos que inicializar o $Id propriedade com null porque não podemos saber que é o ID real até depois de ele foi persistido no banco de dados. Isso não é o ideal - $Id não deve ser realmente anulável e permite BlogPost instâncias para existir em um estado incompleto.

Mudar para UUIDs resolve o problema:

class BlogPost { public function __construct( public readonly string $Uuid, public readonly string $Headline, public readonly ?AuthorCollection $Authors=null) {} }   #[POST("/posts")] function createBlogPost(HttpRequest $Request) : void { $headline = $Request -> getField("Headline"); $blogPost = new BlogPost("16763be4-...", $headline); }

Identificadores de postagem agora podem ser gerados dentro do aplicativo sem arriscar valores duplicados. Isso garante que as instâncias de objeto sempre representem um estado válido e não precisem de propriedades de ID anuláveis ​​desajeitadas. O modelo também facilita o manuseio da lógica transacional; registros filho que precisam de uma referência ao pai (como o nosso post Author associações) podem ser inseridos imediatamente, sem uma viagem de ida e volta do banco de dados para buscar o ID que o pai foi atribuído.

No futuro, seu aplicativo de blog poderá mover mais lógica para o cliente. Talvez o frontend ganhe suporte para a criação completa de rascunhos offline, criando efetivamente BlogPost instâncias que persistem temporariamente no dispositivo do usuário. Agora, o cliente pode gerar o UUID da postagem e transmiti-lo ao servidor quando a conectividade de rede for recuperada. Se o cliente recuperasse posteriormente a cópia do rascunho do servidor, ele poderia combiná-lo com qualquer estado local restante, pois o UUID já seria conhecido.

Os UUIDs também ajudam a combinar dados de várias fontes. Mesclar tabelas de banco de dados e caches que usam chaves inteiras pode ser tedioso e propenso a erros. Os UUIDs oferecem exclusividade não apenas nas tabelas, mas no nível de todo o universo. Isso os torna candidatos muito melhores para estruturas e dados replicados que são frequentemente movidos entre diferentes sistemas de armazenamento.

Advertências quando os UUIDs atendem aos bancos de dados

Os benefícios dos UUIDs são bastante atraentes. No entanto, existem várias armadilhas a serem observadas ao usá-las em sistemas reais. Um grande fator a favor dos IDs inteiros é que eles são fáceis de dimensionar e otimizar. Os mecanismos de banco de dados podem indexar, classificar e filtrar prontamente uma lista de números que vão apenas em uma direção.

O mesmo não pode ser dito para UUIDs. Para começar, os UUIDs são quatro vezes maiores que os inteiros (36 bytes versus 4 bytes); para grandes conjuntos de dados, isso pode ser uma consideração significativa por si só. Os valores também são muito mais complicados de classificar e indexar, principalmente no caso dos UUIDs aleatórios mais comuns. Sua natureza aleatória significa que eles não têm ordem natural. Isso prejudicará o desempenho da indexação se você usar um UUID como chave primária.

Esses problemas podem se agravar em um banco de dados bem normalizado que faz uso intenso de chaves estrangeiras. Agora você pode ter muitas tabelas relacionais, cada uma contendo referências aos seus UUIDs de 36 bytes. Eventualmente, a memória extra necessária para realizar junções e classificações pode ter um impacto significativo no desempenho do seu sistema.

Você pode atenuar parcialmente os problemas armazenando seus UUIDs como dados binários. Isso significa um BINARY(16) coluna em vez de VARCHAR(36). Alguns bancos de dados, como o PostgreSQL, incluem um UUID tipo de dados; outros como o MySQL têm funções que podem converter uma string UUID em sua representação binária e vice-versa. Essa abordagem é mais eficiente, mas lembre-se de que você ainda usará recursos extras para armazenar e selecionar seus dados.

Uma estratégia eficaz pode ser manter inteiros como suas chaves primárias, mas adicionar um campo UUID extra para referência do seu aplicativo. As tabelas de links relacionais podem usar IDs para melhorar o desempenho enquanto seu código busca e insere objetos de nível superior com UUIDs. Tudo se resume ao seu sistema, sua escala e suas prioridades: quando você precisa de geração de ID descentralizada e mesclagem de dados direta, os UUIDs são a melhor opção, mas você precisa reconhecer as desvantagens.

Resumo

UUIDs são valores exclusivos que você pode usar com segurança para geração de identidade descentralizada. Colisões são possível, mas deve ser tão raro que pode ser descartado de consideração. Se você gerasse um bilhão de UUIDs por segundo durante um século inteiro, a probabilidade de encontrar uma duplicata seria de cerca de 50%, supondo que houvesse entropia suficiente disponível.

Você pode usar UUIDs para estabelecer a identidade independentemente de seu banco de dados, antes que ocorra uma inserção. Isso simplifica o código no nível do aplicativo e evita que objetos identificados incorretamente existam em seu sistema. Os UUIDs também auxiliam na replicação de dados garantindo exclusividade independente do armazenamento de dados, dispositivo ou ambiente, ao contrário das tradicionais chaves inteiras que operam no nível da tabela.

Embora os UUIDs sejam agora onipresentes no desenvolvimento de software, eles não são uma solução perfeita. Os recém-chegados tendem a se fixar na possibilidade de colisões, mas isso não deve ser sua principal consideração, a menos que seu sistema seja tão sensível que a exclusividade deva ser garantida.

O desafio mais aparente para a maioria dos desenvolvedores diz respeito ao armazenamento e recuperação de UUIDs gerados. Ingenuamente usando um VARCHAR(36) (ou retirando os hífens e usando VARCHAR(32)) pode prejudicar seu aplicativo ao longo do tempo, pois a maioria das otimizações de indexação de banco de dados será ineficaz. Pesquise os recursos integrados de manipulação de UUID do seu sistema de banco de dados para garantir que você obtenha o melhor desempenho possível de sua solução.

Adicione ao Google Notícias