Como criar datas aleatórias no MySQL

Com o uso das funções CONCAT(), FLOOR() e RAND(), é possível criar datas aleatórias no MySQL. Como o comando UPDATE, você pode efetuar a substituição de todas as datas de uma tabela por outras completamente aleatórias.
Qualquer que seja o seu motivo, imagino que você queira ter controle sobre as datas geradas aleatoriamente — que os anos, os meses e, possivelmente, os dias estejam dentro de faixas especificas.
No exemplo, abaixo, vamos criar datas em que apenas os meses serão aleatórios, variando de 1 a 12:

SELECT CONCAT('2015-',FLOOR(1+RAND()*12),'-02');
+-----------------------------------------+
| CONCAT('2015-',FLOOR(1+RAND()*12),'-02') |
+-----------------------------------------+
|  2015-2-02                              |
+-----------------------------------------+

Agora, vamos usar o ano e o dia atuais, com a função CURDATE():

SELECT CONCAT(YEAR(CURDATE()),'-',FLOOR(1+RAND()*12),'-',DAY(CURDATE()));
+------------------------------------------------------------------+
| CONCAT(YEAR(CURDATE()),'-',FLOOR(1+RAND()*12),'-',DAY(CURDATE())) |
+------------------------------------------------------------------+
| 2015-5-15                                                        |
+------------------------------------------------------------------+

Altere as queries para que se encaixem às suas necessidades.
Embora sejam válidas, as datas dos exemplos acima, não se encaixam nos padrões ISO 8601 e não poderão ser corretamente gravadas dentro de campos date ou datetime.
Para tanto, as datas teriam que ser 2015-02-02 e 2015-05-15 — ou seja, 4 dígitos na seção do ano, 2 dígitos na seção do mês e 2 dígitos na seção do dia.
Para garantir que os números dos meses e dos dias satisfaçam estas condições, seguem os exemplos anteriores, reformulados, com a inclusão da função LPAD():

SELECT CONCAT('2015-',LPAD(FLOOR(1+RAND()*12),2,'0'),'-02');
+------------------------------------------------------+
| CONCAT('2015-',LPAD(FLOOR(1+RAND()*12),2,'0'),'-02') |
+------------------------------------------------------+
| 2015-02-02                                           |
+------------------------------------------------------+

… e no segundo exemplo:

SELECT CONCAT(YEAR(CURDATE()),'-',LPAD(FLOOR(1+RAND()*12),2,'0'),'-',DAY(CURDATE()));
+-------------------------------------------------------------------------------+
| CONCAT(YEAR(CURDATE()),'-',LPAD(FLOOR(1+RAND()*12),2,'0'),'-',DAY(CURDATE())) |
+-------------------------------------------------------------------------------+
| 2015-10-16                                                                    |
+-------------------------------------------------------------------------------+

Leia mais sobre o uso das funções CONCAT() e LPAD() em Como converter strings de data para padrão ISO 8601.

Como substituir as datas de uma coluna da tabela por novas datas aleatórias

Para mudar todas as datas de uma coluna, dentro da tabela, use o UPDATE:

UPDATE clientesEstaduais SET DataCadastro = CONCAT('2015-',LPAD(FLOOR(1+RAND()*12),2,'0'),'-02');

Substitua, no exemplo acima, ‘clientesEstaduais’ pelo nome da sua tabela e ‘DataCadastro’ pelo nome da coluna cujas informações serão alteradas.
Se você quiser, pode obter a tabela ‘clientesEstaduais’ aqui.
No próximo exemplo, todos os componentes da data serão atualizados aleatoriamente (ano, mês e dia) — obedecendo os seguintes parâmetros:

  • Os anos têm que estar entre 2014 e 2016
  • Os valores referentes aos meses têm que estar comprendidos entre 1 e 12
  • Os valores dos dias, para ter alguma segurança em relação a meses com quantidade de dias diferentes, ficam compreendidos entre 1 e 27 — o que garante que nenhum fique com data inválida (por exemplo: 2016-02-31)

Veja o código:

UPDATE clientesEstaduais SET DataCadastro = CONCAT(FLOOR(2014+RAND()*3),'-', LPAD(FLOOR(1+RAND()*12),2,'0'),'-', LPAD(FLOOR(1+RAND()*27),2,'0'));

Desta vez, a gama de datas contidas na minha tabela, ficou bem mais variada:

SELECT DataCadastro FROM clientesEstaduais LIMIT 10;
+--------------+
| DataCadastro |
+--------------+
| 2016-11-07   |
| 2015-01-14   |
| 2015-09-04   |
| 2015-02-09   |
| 2014-04-07   |
| 2015-02-16   |
| 2015-05-16   |
| 2016-11-11   |
| 2014-10-07   |
| 2016-10-08   |
+--------------+

Como converter strings de data para padrões aceitáveis pelo MySQL

Uma string, representando uma informação de data, não pode ser gravada corretamente no MySQL, se não estiver de acordo com as normas descritas na ISO 8601.
Para evitar erros e imprevistos, devemos usar algumas funções do MySQL, para tratar as strings e garantir que as datas sejam armazenadas adequadamente, de acordo com o você previa.
mysql-concat-date
Os formatos de data e hora, no MySQL, são expostos em maiores detalhes neste artigo.
Uma dos métodos para converter strings em datas padrão do MySQL, faz uso da função CONCAT().
No exemplo, abaixo, veja que as duas colunas expressam datas:

  • a primeira expressa datas dentro do formato DATETIME e está de acordo com o padrão ISO 8601;
  • a segunda contém datas constituídas a partir da primeira coluna, só que algumas destas datas estão fora do padrão ISO, que pede que o número referente ao mês ou ao dia seja representado por 2 dígitos — ou seja, o correto é ’04’. O mês ‘4’ (sem o dígito zero, à sua esquerda) está fora do padrão e, portanto, invalida esta string, como data passível de ser armazenada.
SELECT DataNascimentoCliente, CONCAT(YEAR(DataNascimentoCliente),'-',MONTH(DataNascimentoCliente),'-',DAY(DataNascimentoCliente)) FROM CadastroClientes LIMIT 5;
+-----------------------+-----------------------------------------------------------------------------------------------------+
| DataNascimentoCliente | CONCAT(YEAR(DataNascimentoCliente),'-',MONTH(DataNascimentoCliente),'-',DAY(DataNascimentoCliente)) |
+-----------------------+-----------------------------------------------------------------------------------------------------+
| 1984-04-11 19:32:05   | 1984-4-11                                                                                           |
| 1984-12-22 02:53:07   | 1984-12-22                                                                                          |
| 1981-05-14 03:12:50   | 1981-5-14                                                                                           |
| 1983-10-01 22:40:44   | 1983-10-1                                                                                           |
| 1969-12-16 11:01:39   | 1969-12-16                                                                                          |
+-----------------------+-----------------------------------------------------------------------------------------------------+
5 rows in set (0.00 sec)

Se temos 3 datas inválidas, na relação acima, vejamos como resolver o problema e inseri-las no padrão de armazenamento de datas do MySQL.
Use a função LPAD() para completar os caracteres faltantes na parte do Mês e na parte do dia:

SELECT DataNascimentoCliente, CONCAT(YEAR(DataNascimentoCliente),'-',LPAD(MONTH(DataNascimentoCliente),2,'0'),'-',LPAD(DAY(DataNascimentoCliente),2,'0')) FROM CadastroClientes LIMIT 5;
+-----------------------+-----------------------------------------------------------------------------------------------------------------------------+
| DataNascimentoCliente | CONCAT(YEAR(DataNascimentoCliente),'-',LPAD(MONTH(DataNascimentoCliente),2,'0'),'-',LPAD(DAY(DataNascimentoCliente),2,'0')) |
+-----------------------+-----------------------------------------------------------------------------------------------------------------------------+
| 1984-04-11 19:32:05   | 1984-04-11                                                                                                                  |
| 1984-12-22 02:53:07   | 1984-12-22                                                                                                                  |
| 1981-05-14 03:12:50   | 1981-05-14                                                                                                                  |
| 1983-10-01 22:40:44   | 1983-10-01                                                                                                                  |
| 1969-12-16 11:01:39   | 1969-12-16                                                                                                                  |
+-----------------------+-----------------------------------------------------------------------------------------------------------------------------+
5 rows in set (0.01 sec)

Isto é o suficiente para padronizar as datas da segunda coluna, de acordo com o que o MySQL exige.
O próximo passo é desnecessário — mas tem o objetivo de melhorar a estética do relatório, com a redução da extensão dos títulos das colunas:

SELECT DataNascimentoCliente AS "Data original", CONCAT(YEAR(DataNascimentoCliente),'-',LPAD(MONTH(DataNascimentoCliente),2,'0'),'-',LPAD(DAY(DataNascimentoCliente),2,'0')) AS "Data" FROM CadastroClientes LIMIT 5;
+---------------------+------------+
| Data original       | Data       |
+---------------------+------------+
| 1984-04-11 19:32:05 | 1984-04-11 |
| 1984-12-22 02:53:07 | 1984-12-22 |
| 1981-05-14 03:12:50 | 1981-05-14 |
| 1983-10-01 22:40:44 | 1983-10-01 |
| 1969-12-16 11:01:39 | 1969-12-16 |
+---------------------+------------+
5 rows in set (0.00 sec)

Na forma em que se encontram, agora, os dados da segunda coluna, podem ser armazenados diretamente nesta ou em outra tabela e podem participar de operações aritméticas envolvendo datas.
A função LPAD() serve para ajustar as strings. Possui 3 parâmetros e sua sintaxe é LPAD(str,len,padstr) em que:

  • str — é a string sobre a qual será feita a operação
  • len — o limite de tamanho que a string deve ter
  • padstr — caractere que deverá preencher a nova os espaços “sobrantes”, se houver

O “L” do nome LPAD, quer dizer left (esquerda) e indica de que ponto da string a operação deverá começar.
Por fim, das inúmeras maneiras existentes para se padronizar datas no MySQL para o formato ISO, esta é apenas uma.

Como decompor ou combinar strings no MySQL

Saiba como quebrar ou separar partes de uma cadeia de caracteres para obter uma substring ou como combinar mais de uma string para obter uma cadeia maior.
Partes deste assunto, já foram abordadas em outros artigos no site — portanto, se quiser saber um pouco mais sobre algum quesito, clique nos links correspondentes, ao longo do texto.
Outumn trees over lake and mysql logo
A solução para separar trechos de uma cadeia de caracteres é usar uma função de extração de substrings.
Para obter o efeito contrário, use a função CONCAT(). Com esta função, é possível juntar cadeias de caracteres e criar novas formatações para diversos tipos de dados.

Funções para extração de caracteres ou strings no MySQL

A versão 5.7 do MySqL tem mais de 50 funções para lidar com strings.
Ao aprender a lidar com algumas, você estará apto(a) a lidar com todas.
Nos primeiros exemplos deste post, vou mostrar o funcionamento de 3, destas funções: LEFT(), MID() e RIGHT().
Elas servem para extrair substrings de uma cadeia de caracteres da parte à esquerda, do meio e da direita, respectivamente.
Neste primeiro exemplo, vou mostrar como retirar 2 caracteres destas partes da relação de cidades, da tabela ClientesCidades.

SELECT CidadeCliente, LEFT(CidadeCliente, 2) AS "Primeira parte", MID(CidadeCliente, 3, 2) AS "Parte do meio", RIGHT(CidadeCliente, 2) AS "Última parte" FROM ClientesCidades LIMIT 5;
+---------------+----------------+---------------+---------------+
| CidadeCliente | Primeira parte | Parte do meio | Última parte  |
+---------------+----------------+---------------+---------------+
| Buti          | Bu             | ti            | ti            |
| Whitehorse    | Wh             | it            | se            |
| Bertiolo      | Be             | rt            | lo            |
| Exeter        | Ex             | et            | er            |
| Fortune       | Fo             | rt            | ne            |
+---------------+----------------+---------------+---------------+
5 rows in set (0.00 sec)

A função LEFT() retorna o número especificado e caracteres de dentro de uma string. Veja um outro exemplo:

SELECT LEFT('GNU/Linux',3);
+----------------------+
| LEFT('GNU/Linux', 3) |
+----------------------+
| GNU                  |
+----------------------+
1 row in set (0.00 sec)

Com a função RIGHT(), tudo funciona do mesmo jeito. Só que na direção inversa:

SELECT RIGHT('GNU/Linux', 5);
+-----------------------+
| RIGHT('GNU/Linux', 5) |
+-----------------------+
| Linux                 |
+-----------------------+
1 row in set (0.00 sec)

A função MID() é sinônima de SUBSTRING(). Ela pede que você informe em que posição, no meio da string, a contagem deve começar:

SELECT MID('Debian GNU/Linux', 8, 3);

A declaração pede para “retirar 3 caracteres, a partir da 8a. posição”:

+-------------------------------+
| MID('Debian GNU/Linux', 8, 3) |
+-------------------------------+
| GNU                           |
+-------------------------------+
1 row in set (0.00 sec)

Mysql string functions
Clique para ampliar.

A função SUBSTR() tem funcionamento semelhante, de acordo com a documentação do MySQL (veja link ao final do texto).
A função LEFT() pode ser usada para encontrar todos os nomes, dentro de uma tabela, que comecem com uma determinada letra do alfabeto:

SELECT LEFT(nomeCliente,6) FROM ClientesCidades WHERE LEFT(nomeCliente,1)="W";
+---------------------+
| LEFT(nomeCliente,6) |
+---------------------+
| Winter              |
| Willow              |
| Wilma               |
| Willow              |
| Willow              |
| Wyomin              |
| Willa               |
| Wynne               |
+---------------------+
8 rows in set (0.00 sec)

Veja como obter uma relação de nomes de clientes cujos nomes começam com W, X, Y ou Z (as últimas letras do alfabeto em inglês), em ordem alfabética:

SELECT nomeCliente AS "Clientes de W a Z" FROM ClientesCidades WHERE LEFT(nomeCliente,1)>="W" ORDER BY nomeCliente;
+-------------------+
| Clientes de W a Z |
+-------------------+
| Willa Kerr        |
| Willow Graham     |
| Willow Mitchell   |
| Willow Simmons    |
| Wilma Hill        |
| Winter Fischer    |
| Wynne Bauer       |
| Wyoming Graham    |
| Xantha Wise       |
| Xyla Dennis       |
| Yen Espinoza      |
| Yetta Wood        |
| Yoshi Nguyen      |
| Yvonne Wilcox     |
| Zelenia Brady     |
| Zelenia Moss      |
| Zenia Carr        |
| Zephr Webb        |
| Zia Fernandez     |
+-------------------+
19 rows in set (0.00 sec)

Você pode usar a função CONCAT(), para construir novas strings, usando os nomes dos clientes:

SELECT CONCAT("A Cliente ",nomeCliente, " mora em ",cidadeCliente) AS "Clientes de Y a Z" FROM ClientesCidades WHERE LEFT(nomeCliente,1)>="Y" ORDER BY nomeCliente;

Veja o meu resultado:

+------------------------------------------------+
| Clientes de Y a Z                              |
+------------------------------------------------+
| A Cliente Yen Espinoza mora em Pramaggiore     |
| A Cliente Yetta Wood mora em Doues             |
| A Cliente Yoshi Nguyen mora em Daiano          |
| A Cliente Yvonne Wilcox mora em Sherbrooke     |
| A Cliente Zelenia Brady mora em Modena         |
| A Cliente Zelenia Moss mora em Elx             |
| A Cliente Zenia Carr mora em Wernigerode       |
| A Cliente Zephr Webb mora em Recanati          |
| A Cliente Zia Fernandez mora em Market Drayton |
+------------------------------------------------+
9 rows in set (0.00 sec)

Como você pode ver, dá pra brincar bastante com as funções de manipulação de strings. Faça as suas experiências!
Você pode usar a função CONCAT(), para alterar os valores de uma coluna.
No exemplo, abaixo, acrescentamos a string “_abc” aos nomes dos clientes da tabela ClientesCidades:

UPDATE ClientesCidades SET NomeCliente = CONCAT(NomeCliente,"_abc");
SELECT NomeCliente FROM ClientesCidades LIMIT 5;
+---------------------+
| NomeCliente         |
+---------------------+
| Dara Chase_abc      |
| Hanae Kane_abc      |
| Jaden Moon_abc      |
| Cathleen Harvey_abc |
| Marcia Cole_abc     |
+---------------------+
5 rows in set (0.00 sec)

Para desfazer esta bagunça, você pode usar a função LENGTH() para posicionar a função LEFT() antes destes 4 caracteres e gravar o resultado:

UPDATE ClientesCidades SET NomeCliente = LEFT(NomeCliente, LENGTH(NomeCliente)-4);

E veja como tudo volta ao normal:

SELECT NomeCliente FROM ClientesCidades LIMIT 5;
+-----------------+
| NomeCliente     |
+-----------------+
| Dara Chase      |
| Hanae Kane      |
| Jaden Moon      |
| Cathleen Harvey |
| Marcia Cole     |
+-----------------+
5 rows in set (0.00 sec)

Referências:

Como combinar nomes de colunas com a função CONCAT() do MySQL

No MySQL, a função CONCAT tem a função de concatenar strings, ou seja, juntar cadeias de caracteres com o objetivo de formar novos nomes para as suas colunas e enriquecer a apresentação dos dados da sua tabela.
Capa do tutorial da função concat no MySQL
No artigo Como nomear as colunas das tabelas no MySQL, mostrei como melhorar a apresentação das colunas ao exibir as informações da sua tabela — recomendo dar uma olhada.
Neste texto, vou mostrar como usar a função CONCAT() para juntar valores alfanuméricos e formar novos nomes de campos em uma tabela.

Como usar a função CONCAT, do MySQL, para juntar cadeias de caracteres

Em conjunto com o alias (ou AS) é possível criar nomes mais interessantes e significativos para as colunas exibidas de uma tabela.
Veja a sintaxe da função CONCAT():
CONCAT(string1,string2,string3...);
Pode ficar mais fácil de entender, dentro de um exemplo prático.
Veja como concatenar as strings “just”, “in” e “case”:
CONCAT("just","in","case");
O resultado da operação acima é justincase. Foi fácil?
Tome, como exemplo, a seguinte tabela:

SELECT * FROM ClientesCidades WHERE Id<10;
+----+-----------------+--------------+------------------+-------------+
| id | NomeCliente     | IdadeCliente | CidadeCliente    | CredCliente |
+----+-----------------+--------------+------------------+-------------+
|  1 | Dara Chase      |           40 | Buti             |          21 |
|  2 | Hanae Kane      |           26 | Whitehorse       |          28 |
|  3 | Jaden Moon      |           29 | Bertiolo         |          17 |
|  4 | Cathleen Harvey |           39 | Exeter           |          12 |
|  5 | Marcia Cole     |           49 | Fortune          |          13 |
|  6 | Winter Fischer  |           47 | Girifalco        |          53 |
|  7 | Irene Mann      |           48 | Rocca San Felice |          78 |
|  8 | Yetta Wood      |           46 | Doues            |          89 |
|  9 | Alfreda Church  |           38 | Tarnów           |          96 |
+----+-----------------+--------------+------------------+-------------+
9 rows in set (0.00 sec)

Vamos usar o CONCAT() e o AS para exibir a idade de cada cliente entre colchetes e ao lado de cada nome:

SELECT Id AS Ordem, CONCAT(NomeCliente,'[',IdadeCliente,']') AS 'Cliente[Idade]' FROM ClientesCidades WHERE Id<10;
+-------+---------------------+
| Ordem | Cliente[Idade]       |
+-------+---------------------+
|     1 | Dara Chase[40]      |
|     2 | Hanae Kane[26]      |
|     3 | Jaden Moon[29]      |
|     4 | Cathleen Harvey[39] |
|     5 | Marcia Cole[49]     |
|     6 | Winter Fischer[47]  |
|     7 | Irene Mann[48]      |
|     8 | Yetta Wood[46]      |
|     9 | Alfreda Church[38]  |
+-------+---------------------+
9 rows in set (0.00 sec)

Vamos elaborar melhor este exemplo, incluindo informações sobre sua cidade e o valor de seu crédito:

SELECT CONCAT(NomeCliente,', tem ',IdadeCliente,' anos de idade. Mora em ',CidadeCliente,' e possui R$ ',CredCliente,' em créditos.') AS 'Maiores correntistas' FROM ClientesCidades WHERE CredCliente > 97;
+------------------------------------------------------------------------------------+
| Maiores correntistas                                                               |
+------------------------------------------------------------------------------------+
| Cynthia Levy, tem 21 anos de idade. Mora em Pukekohe e possui R$ 99 em créditos.   |
| Tasha Walters, tem 19 anos de idade. Mora em Goutroux e possui R$ 98 em créditos.  |
| Zelenia Moss, tem 18 anos de idade. Mora em Elx e possui R$ 99 em créditos.        |
+------------------------------------------------------------------------------------+
3 rows in set (0.00 sec)

Experimente outras combinações, para obter resultados diferentes e fixar melhor o aprendizado.
Se quiser aprofundar o aprendizado, use caixa de busca, no topo deste site, para encontrar outros exemplos MySQL.
Divirta-se!