> ## Documentation Index
> Fetch the complete documentation index at: https://villagesql.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Gerando Dados Aleatórios no MySQL

> Como gerar dados aleatórios no MySQL — bytes criptograficamente seguros, UUIDs aleatórios e dados de teste — usando RAND(), RANDOM_BYTES() e a gen_random_bytes() do VillageSQL.

> [card] [VillageSQL is a drop-in replacement for MySQL with extensions.](https://villagesql.com/docs/en/8.4/stable/install-server.md)
>
> All examples on this page work on VillageSQL. Install Now →

A `RAND()` do MySQL gera números pseudoaleatórios para coisas como embaralhar resultados de consultas. Ela não é criptograficamente segura, o que importa quando você está gerando tokens, salts ou nonces. `RANDOM_BYTES()` preenche essa lacuna, e a extensão `vsql_crypto` do VillageSQL adiciona `gen_random_bytes()` e `gen_random_uuid()` como parte de uma API de criptografia unificada.

## As Funções Aleatórias do MySQL

O MySQL fornece duas funções aleatórias embutidas com propósitos muito diferentes:

**`RAND()`** — Retorna um float pseudoaleatório entre 0 e 1. Rápida e adequada para aplicações sem exigência de segurança: resultados de consulta aleatorizados, amostragem ponderada, seleção aleatória de linhas. Não é criptograficamente segura.

```sql theme={null}
-- Shuffle query results
SELECT * FROM products ORDER BY RAND() LIMIT 10;

-- Random integer in a range
SELECT FLOOR(RAND() * 100) AS random_0_to_99;
```

**`RANDOM_BYTES(n)`** — Retorna `n` bytes aleatórios criptograficamente seguros como `VARBINARY`. Use-a para tokens, salts, nonces e chaves.

```sql theme={null}
-- 16-byte cryptographic token
SELECT HEX(RANDOM_BYTES(16)) AS token;

-- Use as a session token
INSERT INTO sessions (token, user_id, expires_at)
VALUES (RANDOM_BYTES(32), 42, NOW() + INTERVAL 7 DAY);
```

## Com o VillageSQL: gen\_random\_bytes() e gen\_random\_uuid()

A extensão `vsql_crypto` do VillageSQL adiciona `gen_random_bytes()` e `gen_random_uuid()`, que usam a `RAND_bytes()` do OpenSSL — a mesma fonte de entropia de `RANDOM_BYTES()`.

```sql theme={null}
INSTALL EXTENSION vsql_crypto;
```

O principal motivo para usá-las no lugar das funções embutidas é a consistência: quando você já usa `digest()`, `hmac()` ou `encrypt()` da `vsql_crypto`, manter todas as operações de criptografia em uma única extensão simplifica atualizações e auditoria.

```sql theme={null}
-- Cryptographically secure random bytes
SELECT HEX(gen_random_bytes(16)) AS token_hex;
SELECT HEX(gen_random_bytes(32)) AS session_key;

-- Verify length
SELECT LENGTH(gen_random_bytes(24));  -- Returns 24

-- Random UUID v4
SELECT gen_random_uuid();
-- Returns: 'de2ae351-fc1b-4182-b6a5-72d11a341dc3' (different every call)
```

### Gerando dados de teste

Funções aleatórias são úteis para popular tabelas de teste:

```sql theme={null}
-- Insert 1000 rows of test data. WITH RECURSIVE must immediately precede
-- the SELECT it attaches to, so it goes after the INSERT's column list.
INSERT INTO test_users (username, email, score, token)
WITH RECURSIVE n AS (
    SELECT 1 AS i UNION ALL SELECT i + 1 FROM n WHERE i < 1000
)
SELECT
    CONCAT('user_', i),
    CONCAT('user', i, '@example.com'),
    FLOOR(RAND() * 100),
    gen_random_bytes(16)
FROM n;
```

### Tokens de uso único e códigos de convite

```sql theme={null}
CREATE TABLE invites (
    token     VARBINARY(32) PRIMARY KEY,
    email     VARCHAR(255),
    used      TINYINT DEFAULT 0,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO invites (token, email)
VALUES (gen_random_bytes(32), 'newuser@example.com');

-- Return token as hex for use in a URL
SELECT HEX(token) AS invite_link, email FROM invites WHERE used = 0;
```

## Escolhendo a Função Certa

| Função | Saída | Criptograficamente segura | Use quando |
| :- | :- | :- | :- |
| `RAND()` | Float 0–1 | Não | Embaralhar, amostrar, seleção ponderada |
| `FLOOR(RAND() * n)` | Inteiro 0–(n-1) | Não | Inteiros aleatórios para dados de teste |
| `RANDOM_BYTES(n)` | VARBINARY | Sim | Tokens, nonces, salts — embutida no MySQL |
| `gen_random_bytes(n)` | VARBINARY | Sim | O mesmo que RANDOM\_BYTES, unificada com a API da vsql\_crypto |
| `gen_random_uuid()` | VARCHAR (string UUID) | Sim | UUID v4 como string — não exige a vsql\_uuid |

`RANDOM_BYTES()` e `gen_random_bytes()` são funcionalmente equivalentes — as duas retornam a mesma qualidade de aleatoriedade. Se você já usa a `vsql_crypto`, use `gen_random_bytes()` para manter a sua superfície de criptografia em um só lugar. Se você só precisa de bytes aleatórios e nada mais, a `RANDOM_BYTES()` do MySQL funciona bem.

Se você precisa de um tipo UUID com variantes ordenáveis (v7) e armazenamento binário, use a extensão `vsql_uuid` em vez de `gen_random_uuid()`. Consulte [UUIDs no MySQL](https://villagesql.com/docs/pt-BR/guides/uuids.md) para a comparação completa.

## Perguntas Frequentes

#### A RAND() é segura para gerar tokens?

Não. `RAND()` é um gerador de números pseudoaleatórios semeado a partir de um estado previsível. Ela serve para `ORDER BY RAND()` e usos semelhantes sem exigência de segurança, mas tokens gerados com `RAND()` podem, em teoria, ser previstos. Use `RANDOM_BYTES()` ou `gen_random_bytes()` para qualquer coisa sensível à segurança.

#### De quantos bytes preciso para um token seguro?

32 bytes (256 bits) é o padrão para tokens de sessão e chaves de API. 16 bytes (128 bits) é o mínimo para segurança prática. Use 32 para ficar seguro.

#### Posso usar gen\_random\_bytes() como DEFAULT?

Não. O MySQL em si permite funções não determinísticas em expressões DEFAULT — `UUID()`, `RAND()` e `NOW()` funcionam ali. `gen_random_bytes()` é rejeitada especificamente porque é uma função de extensão do VillageSQL registrada como não determinística, e o VEF bloqueia essas funções em expressões DEFAULT independentemente do que o MySQL em si permite. Em vez disso, gere o valor em cada instrução INSERT.

#### Qual é a diferença entre gen\_random\_uuid() e a UUID\_V4() da vsql\_uuid?

`gen_random_uuid()` retorna uma string UUID em `VARCHAR`. A `UUID_V4()` da extensão `vsql_uuid` retorna um tipo `UUID` nativo com armazenamento binário de 16 bytes. Se você usa UUIDs como chaves primárias, prefira `UUID_V4()` ou `UUID_V7()` da `vsql_uuid`. Use `gen_random_uuid()` quando precisar de uma string UUID e não quiser instalar uma extensão separada.

## Solução de Problemas

| Problema | Solução |
| :- | :- |
| `FUNCTION <database>.gen_random_bytes does not exist` | Execute `INSTALL EXTENSION vsql_crypto` |
| Os tokens parecem sequenciais ou previsíveis | Você pode estar usando `RAND()` em vez de `gen_random_bytes()` |
| `gen_random_bytes()` retorna NULL | Verifique se o argumento é um inteiro positivo |
| `DEFAULT (gen_random_bytes(32))` rejeitado | O MySQL não permite defaults não determinísticos — gere em cada INSERT |

## Veja também

* [Hashing de Senhas no MySQL](https://villagesql.com/docs/pt-BR/guides/password-hashing.md) — usando bytes aleatórios como salt para armazenamento de credenciais
* [UUIDs no MySQL](https://villagesql.com/docs/pt-BR/guides/uuids.md) — o UUID v4 é um uso comum de aleatoriedade criptográfica


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.