Gerando dados de teste aleatórios no ClickHouse

Gerar dados aleatórios é útil ao testar novos casos de uso ou fazer benchmarking da sua implementação. O ClickHouse tem uma ampla gama de funções para gerar dados aleatórios que, em muitos casos, eliminam a necessidade de um gerador de dados externo. Este guia apresenta vários exemplos de como gerar conjuntos de dados aleatórios no ClickHouse com diferentes requisitos de aleatoriedade.

Conjunto de dados simples com distribuição uniforme

Caso de uso: Gere rapidamente um conjunto de dados de eventos de usuários com timestamps aleatórios e tipos de evento.

CREATE TABLE user_events (
  event_id UUID,
  user_id UInt32,
  event_type LowCardinality(String),
  event_time DateTime
) ENGINE = MergeTree
ORDER BY event_time;

INSERT INTO user_events
SELECT
  generateUUIDv4() AS event_id,
  rand() % 10000 AS user_id,
  arrayElement(['click','view','purchase'], toUInt32(rand()) % 3 + 1) AS event_type,
  now() - INTERVAL rand() % 3600*24 SECOND AS event_time
FROM numbers(1000000);

rand() % 10000: distribuição uniforme de 10 mil usuários
arrayElement(...): seleciona aleatoriamente um de três tipos de evento
Timestamps distribuídos ao longo das últimas 24 horas

Distribuição exponencial

Caso de uso: Simular valores de compra em que a maioria é baixa, mas alguns são altos.

CREATE TABLE purchases (
  dt DateTime,
  customer_id UInt32,
  total_spent Float32
) ENGINE = MergeTree
ORDER BY dt;

INSERT INTO purchases
SELECT
  now() - INTERVAL randUniform(1,1_000_000) SECOND AS dt,
  number AS customer_id,
  15 + round(randExponential(1/10), 2) AS total_spent
FROM numbers(500000);

Timestamps uniformemente distribuídos em um período recente
randExponential(1/10) — a maioria dos totais fica próxima de 0, com 15 como valor mínimo ([ClickHouse][1], [ClickHouse][2], [Atlantic.Net][3], [GitHub][4])

Eventos distribuídos ao longo do tempo (Poisson)

Caso de uso: Simule chegadas de eventos que se concentram em um período específico (por exemplo, no horário de pico).

CREATE TABLE events (
  dt DateTime,
  event_type String
) ENGINE = MergeTree
ORDER BY dt;

INSERT INTO events
SELECT
  toDateTime('2022-12-12 12:00:00')
    - ((12 + randPoisson(12)) * 3600) AS dt,
  'click' AS event_type
FROM numbers(200000);

Os eventos atingem o pico por volta do meio-dia, com desvio com distribuição de Poisson

Distribuição normal variável ao longo do tempo

Caso de uso: Emular métricas do sistema (por exemplo, uso de CPU) que variam ao longo do tempo.

CREATE TABLE IF NOT EXISTS cpu_metrics (
    host String,
    ts   DateTime,
    usage Float32
) ENGINE = MergeTree
ORDER BY (host, ts);

INSERT INTO cpu_metrics
SELECT
    arrayJoin(['host1','host2','host3']) AS host,
    now() - INTERVAL number SECOND AS ts,
    greatest(0.0, least(100.0,
        (50 + 30 * sin(toUInt32(number) % 86400 / 86400.0 * 2 * pi()))
        + randNormal(0, 10)
    )) AS usage
FROM numbers(10000);

usage segue uma onda senoidal ao longo do dia + aleatoriedade
Valores limitados ao intervalo [0,100]

Dados categóricos e aninhados

Caso de uso: Crie perfis de usuário com interesses múltiplos.

CREATE TABLE user_profiles (
  user_id UInt32,
  interests Array(String),
  scores Array(UInt8)
) ENGINE = MergeTree
ORDER BY user_id;

INSERT INTO user_profiles
SELECT
  number AS user_id,
  arrayShuffle(['sports','music','tech'])[1 + rand() % 3 : 1 + rand() % 3] AS interests,
  [rand() % 100, rand() % 100, rand() % 100] AS scores
FROM numbers(20000);

Comprimento aleatório do array entre 1 e 3
Três pontuações por usuário para cada interesse

Leia o post do blog Gerando dados aleatórios no ClickHouse para ver ainda mais exemplos.

Gerando tabelas aleatórias

A função generateRandomStructure é particularmente útil quando combinada com o mecanismo de tabela generateRandom para testes, benchmarking ou criação de dados simulados com schemas arbitrários. Vamos começar vendo como é uma estrutura aleatória usando a função generateRandomStructure:

SELECT generateRandomStructure(5);

Você pode ver algo assim:

c1 UInt32, c2 Array(String), c3 DateTime, c4 Nullable(Float64), c5 Map(String, Int16)

Você também pode usar uma semente para obter sempre a mesma estrutura:

SELECT generateRandomStructure(3, 42);

c1 String, c2 Array(Nullable(Int32)), c3 Tuple(UInt8, Date)

Agora, vamos criar uma tabela propriamente dita e preenchê-la com dados aleatórios:

CREATE TABLE my_test_table
ENGINE = MergeTree
ORDER BY tuple()
AS SELECT * 
FROM generateRandom(
    'col1 UInt32, col2 String, col3 Float64, col4 DateTime',
    1,  -- semente para gerar os dados
    10  -- número de valores aleatórios diferentes
)
LIMIT 100;  -- 100 linhas

-- Etapa 2: consulte a nova tabela
SELECT * FROM my_test_table LIMIT 5;

┌───────col1─┬─col2──────┬─────────────────────col3─┬────────────────col4─┐
│ 4107652264 │ &b!M-e;7  │  1.0013455832230728e-158 │ 2059-08-14 19:03:26 │
│  652895061 │ Dj7peUH{T │   -1.032074207667996e112 │ 2079-10-06 04:18:16 │
│ 2319105779 │ =D[       │    -2.066555415720528e88 │ 2015-04-26 11:44:13 │
│ 1835960063 │ _@}a      │  -1.4998020545039013e110 │ 2063-03-03 20:36:55 │
│  730412674 │ _}!       │ -1.3578492992094465e-275 │ 2098-08-23 18:23:37 │
└────────────┴───────────┴──────────────────────────┴─────────────────────┘

Vamos combinar as duas funções para criar uma tabela completamente aleatória. Primeiro, veja a estrutura que vamos obter:

SELECT generateRandomStructure(7, 123) AS structure FORMAT vertical;

┌─structure──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ c1 Decimal64(7), c2 Enum16('c2V0' = -21744, 'c2V1' = 5380), c3 Int8, c4 UUID, c5 UUID, c6 FixedString(190), c7 Map(Enum16('c7V0' = -19581, 'c7V1' = -10024, 'c7V2' = 27615, 'c7V3' = -10177, 'c7V4' = -19644, 'c7V5' = 3554, 'c7V6' = 29073, 'c7V7' = 28800, 'c7V8' = -11512), Float64) │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

Agora, crie a tabela com essa estrutura e use a instrução DESCRIBE para ver o que foi criado:

CREATE TABLE fully_random_table
ENGINE = MergeTree
ORDER BY tuple()
AS SELECT * 
FROM generateRandom(generateRandomStructure(7, 123), 1, 10)
LIMIT 1000;

DESCRIBE TABLE fully_random_table;

   ┌─name─┬─type─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1   │ Decimal(18, 7)                                                                                                                                                           │              │                    │         │                  │                │
│ c2   │ Enum16('c2V0' = -21744, 'c2V1' = 5380)                                                                                                                                   │              │                    │         │                  │                │
│ c3   │ Int8                                                                                                                                                                     │              │                    │         │                  │                │
│ c4   │ UUID                                                                                                                                                                     │              │                    │         │                  │                │
│ c5   │ UUID                                                                                                                                                                     │              │                    │         │                  │                │
│ c6   │ FixedString(190)                                                                                                                                                         │              │                    │         │                  │                │
│ c7   │ Map(Enum16('c7V4' = -19644, 'c7V0' = -19581, 'c7V8' = -11512, 'c7V3' = -10177, 'c7V1' = -10024, 'c7V5' = 3554, 'c7V2' = 27615, 'c7V7' = 28800, 'c7V6' = 29073), Float64) │              │                    │         │                  │                │
   └──────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘

Inspecione a primeira linha para ver uma amostra dos dados gerados:

SELECT * FROM fully_random_table LIMIT 1 FORMAT vertical;

Row 1:
──────
c1: 80416293882.257732 -- 80,42 bilhões
c2: c2V1
c3: -84
c4: 1a9429b3-fd8b-1d72-502f-c051aeb7018e
c5: 7407421a-031f-eb3b-8571-44ff279ddd36
c6: g̅b�&��rҵ���5C�\�|��H�>���l'V3��R�[��=3�G�LwVMR*s緾/2�J.���6#��(�h>�lە��L^�M�:�R�9%d�ž�zv��W����Y�S��_no��BP+��u��.0��UZ!x�@7:�nj%3�Λd�S�k>���w��|�&��~
c7: {'c7V8':-1.160941256852442}

​Conjunto de dados simples com distribuição uniforme

​Distribuição exponencial

​Eventos distribuídos ao longo do tempo (Poisson)

​Distribuição normal variável ao longo do tempo

​Dados categóricos e aninhados

​Gerando tabelas aleatórias

Conjunto de dados simples com distribuição uniforme

Distribuição exponencial

Eventos distribuídos ao longo do tempo (Poisson)

Distribuição normal variável ao longo do tempo

Dados categóricos e aninhados

Gerando tabelas aleatórias