Como criar tabelas MySQL em um script PHP

Já expliquei anteriormente, no artigo como criar tabelas no MySQL como realizar esta mesma tarefa dentro da linha de comandos do MySQL.
Neste texto, vou mostrar como obter o resultado através de um script PHP.
Abra o seu editor de textos favorito e vamos ao código:

<html>
<head>
<title>Como criar tabelas com PHP</title>
</head>
<body>
<?php
/* substitua as variáveis abaixo pelas que se adequam ao seu caso */
$dbhost = 'localhost:3036'; // endereco do servidor de banco de dados
$dbuser = 'root'; // login do banco de dados
$dbpass = 'minhasenha'; // senha
$dbname = 'nomebanco'; // nome do banco de dados a ser usado
$conecta = mysql_connect($dbhost, $dbuser, $dbpass, $dbname);
$seleciona = mysql_select_db($dbname);
$sqlcriatabela = "CREATE TABLE contatos (nome VARCHAR(50), telefone VARCHAR(25));";
$criatabela = mysql_query( $sqlcriatabela, $conecta );

// inicia a conexao ao servidor de banco de dados
if(! $conecta )
{
  die("<br />Nao foi possivel conectar: " . mysql_error());
}
echo "<br />Conexao realizada!";

// seleciona o banco de dados no qual a tabela vai ser criada
if (! $seleciona)
{
  die("<br />Nao foi possivel selecionar o banco de dados $dbname");
}
echo "<br />selecionado o banco de dados $dbname";

// finalmente, cria a tabela 
if(! $criatabela )
{
  die("<br />Nao foi possivel criar a tabela: " . mysql_error());
}
echo "<br />A tabela foi criada!";

// encerra a conexão
mysql_close($conecta);
?>
</body>
</html>

Crie uma tabela temporária no MySQL

Ao usar o parâmetro TEMPORARY, a tabela seria criada e depois eliminada, ao final da sessão, com o comando mysql_close($conecta); na linha 39. Assim, a cada vez que a página é recarregada, a tabela é recriada e removida.
Altere o código, pratique e divirta-se!

Como criar tabelas temporárias no MySQL

O uso de uma tabela temporária no MySQL, permite realizar testes ou serviços em uma entidade transitória, sem se preocupar em limpar a sujeira depois.
Ao desconectar-se do servidor, as tabelas temporárias são automaticamente descartadas.
Captur de tela - mysql create temporary table

Quando é útil usar tabelas temporárias no MySQL

Algumas operações requerem que a existência de algumas informações seja curta — e que elas sejam removidas, quando não mais forem necessárias.
A parte da remoção pode ser feita automaticamente pelo MySQL.
Você não precisa se lembrar de apagar uma tabela, que não tem mais serventia, com o comando DROP TABLE.
Para isto, basta criar uma tabela, com a opção TEMPORARY, assim: CREATE TABLE TEMPORARY Nome_da_tabela.
Este assunto foi abordado en passant no artigo Como criar tabelas no MySQL. Vamos procurar nos aprofundar um pouco mais neste assunto, aqui.

Como criar tabelas temporárias no MySQL

Você pode criar tabelas temporárias, mais ou menos, da mesma forma que cria as normais. Só que vai acrescentar a opção TEMPORARY.
Se eu quiser criar uma tabela temporária com o nome de ClientesCidadesTemp a partir da tabela ClientesCidades, uso o seguinte comando:

CREATE TEMPORARY TABLE ClientesCidadesTemp SELECT * FROM ClientesCidades;
Query OK, 200 rows affected (0.27 sec)
Records: 200  Duplicates: 0  Warnings: 0

Use o comando EXPLAIN para verificar a nova tabela temporária:

EXPLAIN ClientesCidadesTemp;
+---------------+-----------------------+------+-----+---------+-------+
| Field         | Type                  | Null | Key | Default | Extra |
+---------------+-----------------------+------+-----+---------+-------+
| id            | mediumint(8) unsigned | NO   |     | 0       |       |
| NomeCliente   | varchar(255)          | YES  |     | NULL    |       |
| IdadeCliente  | mediumint(9)          | YES  |     | NULL    |       |
| CidadeCliente | varchar(255)          | YES  |     | NULL    |       |
| CredCliente   | mediumint(9)          | YES  |     | NULL    |       |
+---------------+-----------------------+------+-----+---------+-------+
5 rows in set (0.03 sec)

Entenda melhor as tabelas temporárias

Se há vantagens em usar tabelas temporárias, por outro lado, há algumas características às quais você precisa estar atento:

  • Se você quiser reusar uma tabela temporária, dentro da mesma sessão, vai precisar removê-la, antes. Tentar criar uma segunda tabela com o mesmo nome da primeira, temporária, vai resultar em erro, caso ela não tenha sido apagada.
  • Uma das propriedades das tabelas temporárias permite que possam ser criadas com o mesmo nome de uma outra tabela permanente e preexistente.
    Neste caso, a tabela permanente fica “escondida”, durante a sessão ou enquanto a temporária ainda existir.
    Isto pode ser útil para criar e testar queries, usando o nome de uma tabela existente, sem afetá-la.
  • Algumas APIs, suportam conexões persistentes em um ambiente web. O seu uso previne que as tabelas temporárias expirem, como já é de esperar, ao fim do script — e possam continuar a ser usadas por outros scripts.
  • O MySQL é um ambiente de servidor de banco de dados com capacidade para atender a múltiplos clientes, cada qual com sua sessão.
    Desta forma, é possível que cada cliente tenha aberto uma tabela temporária. E nada impede que elas tenham os mesmos nomes — cada qual na sua sessão.
  • Há vários outros cuidados a serem tomados, quando estamos lidando com um ambiente de tabelas temporárias.
    Se o seu script cria e modifica tabelas temporárias que “escondem” tabelas permanentes com o mesmo nome, é necessário criar rotinas que verifiquem e testem se você ainda está trabalhando na tabela temporária, como esperado.
    Se um dos programas cliente fizer uma reconexão, após uma queda, você poderá alterar uma tabela permanente, em vez de uma temporária.

Referências:
Leia mais sobre como fazer conexões (persistentes) a um servidor MySQL a partir de um script PHP.

Como inserir o resultado de uma query SELECT em uma tabela MySQL

Neste post vou mostrar como pegar o resultado de uma consulta MySQL e gravá-lo em uma tabela preexistente, em vez de exibi-lo.
Se você deseja criar uma nova tabela a partir de uma query SELECT, sugiro ler o artigo Como criar uma tabela a partir de uma declaração SELECT no MySQL.
Mountain high and mysql logo
O servidor MySQL normalmente retorna o resultado de um SELECT ao cliente que o requisitou.
Se você faz uma requisição a partir do terminal cliente MySQL, é para onde os resultados serão enviados e exibidos.
Neste texto vou mostrar como enviar os resultados de um SELECT para dentro de uma outra tabela.
Copiar resultados de uma tabela para outra pode ser útil em vários casos:

  1. Se você estiver desenvolvendo um algoritmo que modifica uma tabela, certamente seria mais seguro trabalhar em uma cópia — o que evita ter que lidar com as consequências de um desastre em cima de informações importantes para você ou para a empresa em que você trabalha.
  2. Em algumas operações, pode ser interessante trabalhar em uma tabela temporária e, mais tarde, copiar os dados conferidos para a tabela definitiva.
  3. Você pode usar o recurso em um script, que toma dados de uma tabela maior e cria uma pequena tabela de serviços e vai atualizando a tabela principal aos poucos (ou em horários de menor fluxo na rede).
  4. Se você está aprendendo MySQL, pode ser interessante transferir dados para tabelas “de aprendizado” e deixar as tabelas de produção em paz.

Vou mostrar como usar o INSERT ... SELECT para obter informações de uma tabela e inseri-las em outra.
Para isto, vou fazer uso das tabelas ClientesCidades e CliCred. Sugiro adequar os exemplos às suas próprias tabelas. Contudo, se quiser, você pode pegar as minhas mal acabadas tabelas aqui.

Como inserir os resultados da query em uma tabela

A tabela CliCred tem 3 campos coincidentes com a tabela ClientesCidades. Veja o que o comando EXPLAIN mostra (em destaque):

EXPLAIN CliCred;
+-----------+-----------------------+------+-----+---------+----------------+
| Field     | Type                  | Null | Key | Default | Extra          |
+-----------+-----------------------+------+-----+---------+----------------+
| id        | mediumint(8) unsigned | NO   | PRI | NULL    | auto_increment |
| cc_nome   | varchar(255)          | YES  |     | NULL    |                |
| cc_cidade | varchar(255)          | YES  |     | NULL    |                |
| cc_cred   | mediumint(9)          | YES  |     | NULL    |                |
| cc_limite | mediumint(9)          | YES  |     | NULL    |                |
+-----------+-----------------------+------+-----+---------+----------------+
5 rows in set (0.00 sec)

Embaixo, após o comando EXPLAIN, destaquei os campos que correspondem aos que foram destacados em cima:

EXPLAIN ClientesCidades;
+---------------+-----------------------+------+-----+---------+----------------+
| Field         | Type                  | Null | Key | Default | Extra          |
+---------------+-----------------------+------+-----+---------+----------------+
| id            | mediumint(8) unsigned | NO   | PRI | NULL    | auto_increment |
| NomeCliente   | varchar(255)          | YES  |     | NULL    |                |
| IdadeCliente  | mediumint(9)          | YES  |     | NULL    |                |
| CidadeCliente | varchar(255)          | YES  |     | NULL    |                |
| CredCliente   | mediumint(9)          | YES  |     | NULL    |                |
+---------------+-----------------------+------+-----+---------+----------------+
5 rows in set (0.00 sec)

Cada uma destas 2 tabelas tem 100 registros.
Ao final da operação, a tabela ClientesCidades terá recebido os 100 registros da tabela CliCred — e passará a ter 200 registros.
Veja:

INSERT INTO ClientesCidades (NomeCliente, CidadeCliente, CredCliente) SELECT cc_nome, cc_cidade, cc_cred FROM CliCred; 

Vamos analisar o comando dado:

  • INSERT INTO ClientesCidades — Determina em que tabela ocorrerá a alteração (inserção de novos dados).
  • (NomeCliente, CidadeCliente, CredCliente) — Estes são os campos (as colunas) que serão alterados na tabela ClientesCidades.
  • SELECT cc_nome, cc_cidade, cc_cred FROM CliCred — Seleciona os valores contidos nos campos cc_nome, cc_cidade, cc_cred na tabela CliCred, para inserir na primeira tabela.

Veja uma listagem parcial (apenas os 10 últimos registros) da nova tabela ClientesCidades:

SELECT * FROM ClientesCidades where id > 190;
+-----+-------------------+--------------+----------------+-------------+
| id  | NomeCliente       | IdadeCliente | CidadeCliente  | CredCliente |
+-----+-------------------+--------------+----------------+-------------+
| 191 | Paula Wiley       |         NULL | St. Catharines |         187 |
| 192 | Cathleen Thornton |         NULL | Rouvroy        |         289 |
| 193 | Laurel Espinoza   |         NULL | Boneffe        |         131 |
| 194 | Amber Sparks      |         NULL | Kailua         |         256 |
| 195 | Elizabeth Bean    |         NULL | Beaconsfield   |         147 |
| 196 | Eleanor Cleveland |         NULL | Rosciano       |         295 |
| 197 | Virginia Dillon   |         NULL | Metairie       |         209 |
| 198 | Jana Dyer         |         NULL | Birori         |         135 |
| 199 | Kendall Reid      |         NULL | Westkapelle    |         274 |
| 200 | Katell Robinson   |         NULL | Colonnella     |         149 |
+-----+-------------------+--------------+----------------+-------------+
10 rows in set (0.03 sec)

Em uma análise do resultado, note que:

  1. o último valor do campo id, em ClientesCidades, reflete o acréscimo de mais 100 registros. Agora são 200 registros;
  2. 100 nomes de clientes, de cidades e valores de Crédito foram adicionados nos campos NomeCliente, CidadeCliente e CredCliente;
  3. A tabela CliCred não tem o campo IdadeCliente, por isto o valor NULL (nulo) foi gravado nos campos correspondentes.

Como copiar todos os valores de uma tabela para outra

Isto é bem mais fácil e pode realizado com um comando mais enxuto e menor preocupação com a sintaxe.
Vamos supor a existência das tabelas tabela_Origem e tabela_Destino, ambas com estruturas idênticas.
Para copíar os valores da primeira para dentro da segunda, use o seguinte comando:

INSERT INTO tabela_Destino SELECT * FROM tabela_Origem;

E se eu quisesse copiar apenas as informações sobre clientes com créditos superiores a 300?
Vamos retomar (e alterar) o exemplo acima:

INSERT INTO ClientesCidades (NomeCliente, CidadeCliente, CredCliente) SELECT cc_nome, cc_cidade, cc_cred FROM CliCred WHERE cc_cred > 300; 

Como, no caso da minha tabela, nenhum cliente tem valor de crédito superior a 300, o resultado foi este:

Query OK, 0 rows affected (0.00 sec)
Records: 0  Duplicates: 0  Warnings: 0

Uma última dica: Você pode usar a mesma tabela como origem e destino.

Divirta-se e tenha um bom aprendizado!

Como nomear as colunas das tabelas no MySQL

A nomenclatura dos campos ou das colunas das tabelas nem sempre são legíveis ou facilmente entendíveis. Como raramente é necessário mostrar uma tabela nua e crua, sem filtragem ou formatação a um usuário, não existe a preocupação de usar nomes “apresentáveis” ou que sejam autoexplicativos a qualquer um que a acesse.
captura de tela mysql describe tabela
A escolha dos nomes dos campos de uma tabela, em um banco de dados, obedece a outros critérios e regras.
Normalmente, o desenvolvedor usa nomes que façam sentido para si.
Há momentos, contudo, em que é necessário fazer um relatório ou mostrar resultados direto do cliente MySQL. Para estes casos, é possível usar a declaração SELECT para renomear os cabeçalhos ou os nomes dos campos de uma tabela.
Veja o exemplo de tabela, abaixo:

DESCRIBE ClientesCidades;
+---------------+-----------------------+------+-----+---------+----------------+
| Field         | Type                  | Null | Key | Default | Extra          |
+---------------+-----------------------+------+-----+---------+----------------+
| id            | mediumint(8) unsigned | NO   | PRI | NULL    | auto_increment |
| NomeCliente   | varchar(255)          | YES  |     | NULL    |                |
| IdadeCliente  | mediumint(9)          | YES  |     | NULL    |                |
| CidadeCliente | varchar(255)          | YES  |     | NULL    |                |
| CredCliente   | mediumint(9)          | YES  |     | NULL    |                |
+---------------+-----------------------+------+-----+---------+----------------+
5 rows in set (0.00 sec)

No exemplo, acima, os nomes não estão “tão ruins”, assim. Dá para entender, sem muito esforço, o que cada um significa e que informações será possível encontrar em cada campo desta tabela.
Se fôssemos exibir o conteúdo desta tabela, teríamos algo parecido com isto (em destaque, os nomes das colunas):

SELECT * FROM ClientesCidades WHERE id<5;
+----+-----------------+--------------+---------------+-------------+
| 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 |
+----+-----------------+--------------+---------------+-------------+
4 rows in set (0.00 sec)

Se você gerar uma coluna de uma alteração no seu resultado, esta expressão será usada como nome da coluna. Isto pode gerar nomes ainda maiores e, em certos casos, “esquisitos”:

SELECT id*10, NomeCliente, IdadeCliente+30, CredCliente*10 FROM ClientesCidades WHERE id<5;

Abaixo, os nomes das colunas (em destaque) refletem as operações realizados nos dados:

 +-------+-----------------+-----------------+----------------+
| id*10 | NomeCliente     | IdadeCliente+30 | CredCliente*10 |
+-------+-----------------+-----------------+----------------+
|    10 | Dara Chase      |              70 |            210 |
|    20 | Hanae Kane      |              56 |            280 |
|    30 | Jaden Moon      |              59 |            170 |
|    40 | Cathleen Harvey |              69 |            120 |
+-------+-----------------+-----------------+----------------+
4 rows in set (0.00 sec)

Você pode melhorar esta apresentação com o recurso de aliases do MySQL para obter nomes diferenciados nas colunas da tabela.
Em uma apresentação, pode ser desejável usar nomes de campos mais significativos para a sua audiência. Veja este exemplo:

SELECT id AS 'Ordem', NomeCliente AS 'Cliente', IdadeCliente AS 'Idade', CidadeCliente AS 'Localidade', CredCliente AS 'Crédito disponível' FROM ClientesCidades WHERE id<5;

Em destaque (novamente), os novos nomes das colunas:

+-------+-----------------+-------+------------+----------------------+
| Ordem | Cliente         | Idade | Localidade | Crédito disponível   |
+-------+-----------------+-------+------------+----------------------+
|     1 | Dara Chase      |    40 | Buti       |                   21 |
|     2 | Hanae Kane      |    26 | Whitehorse |                   28 |
|     3 | Jaden Moon      |    29 | Bertiolo   |                   17 |
|     4 | Cathleen Harvey |    39 | Exeter     |                   12 |
+-------+-----------------+-------+------------+----------------------+
4 rows in set (0.00 sec)

Vamos melhorar mais a apresentação da tabela?
No próximo exemplo, irei aumentar em 3% o crédito de cada cliente:

SELECT NomeCliente AS 'Cliente', CredCliente AS 'Crédito', CredCliente*0.03 AS 'Juros',CredCliente+CredCliente*0.03 AS 'Crédito corrigido' FROM ClientesCidades WHERE id<5;

O resultado mostra uma coluna com o valor do crédito inicial, o valor dos juros (3%) e a soma do crédito ao valor dos juros:

+-----------------+----------+-------+--------------------+
| Cliente         | Crédito  | Juros | Crédito corrigido  |
+-----------------+----------+-------+--------------------+
| Dara Chase      |       21 |  0.63 |              21.63 |
| Hanae Kane      |       28 |  0.84 |              28.84 |
| Jaden Moon      |       17 |  0.51 |              17.51 |
| Cathleen Harvey |       12 |  0.36 |              12.36 |
+-----------------+----------+-------+--------------------+
4 rows in set (0.00 sec)

Desta maneira, nenhuma conta foi exibida nos resultados. Nenhum sinal de porcentagem foi mostrado.
A saída da query, ficou limpa e fácil de entender.

Como listar resultados das tabelas com linhas numeradas no MySQL

Veja como numerar cada linha do resultado de uma query no MySQL. A solução pode ser implementada com uma saída pós processada ou com o uso de uma variável SQL.
mysql numbered lines tables
Neste texto, vou mostrar 2 maneiras bem objetivas e práticas para obter os resultados de uma query (ou consulta) MySQL em linhas numeradas, dentro de uma tabela.

Como obter uma relação numerada de itens de uma tabela via linha de comando

Na linha de comando do Linux ou Unix, você pode combinar a execução de código MySQL com o comando cat -n, conforme é possível observar no exemplo abaixo:

mysql -u root -p -N -e "SELECT nome, credito FROM minhaTabela" tutorial | cat -n
Enter password: 
     1	Geoffrey Rojas	9.33
     2	Brenda N. Reynolds	9.03
     3	Unity Peterson	9.19
     4	Gay Warren	9.11
     5	Hedda E. Kaufman	9.71
     6	Audrey X. Silva	9.21
     7	Myra J. Wright	9.49
     8	Wilma Bird	9.45
     9	Thaddeus P. Shaw	9.06

Com este método, não é preciso entrar no MySQL para conseguir realizar a tarefa.
Vamos dissecar o comando?

  1. mysql -u root -p— início clássico para entrar no cliente MySQL, como root. Como a senha não é fornecida na linha de comando, ela será pedida a seguir.
  2. -N— faz com que a saída do comando não exiba os nomes das colunas.
  3. -e— executa o comando, que segue entre aspas e sai do cliente MySQL. Opcionalmente, você pode usar a variante --execute.
  4. "SELECT nome, credito FROM minhaTabela"query ou consulta a ser executada.
  5. tutorial— banco de dados a ser inquirido.
  6. | cat -n— direciona a saída ao comando cat. A opção -n especifica que cada linha deverá ser contada e numerada.

Neste caso, portanto, quem numera as linhas não é o MySQL, mas o utilitário cat.
Em listas muito grandes, este método permite usar o comando grep, para filtrar os resultados.
Se você tem interesse em saber mais sobre como executar queries MySQL da linha de comando do Linux/Unix, leia este artigo.

Use uma variável SQL para obter uma lista numerada

Uma alternativa inteligente, para solucionar o problema é usar uma variável auto incrementável para listar as linhas numeradas.
Esta solução, ao contrário da anterior, pede que você execute os comandos de dentro do cliente MySQL.
Veja o exemplo:

SET @n = 0;
Query OK, 0 rows affected (0.00 sec)

SELECT @n := @n+1 AS ordem, nome, credito, debito FROM minhaTabela;
+-------+-----------------------+---------+--------+
| ordem | nome                  | credito | debito |
+-------+-----------------------+---------+--------+
|     1 | Lani Z. Lawrence      | 4.70    | 2.01   |
|     2 | Geoffrey Rojas        | 9.33    | 6.09   |
|     3 | Holly Mcknight        | 3.79    | 9.84   |
|     4 | Emerson F. Tate       | 6.09    | 8.57   |
|     5 | Alyssa A. Goodman     | 3.29    | 4.73   |
|     6 | Kibo H. Cruz          | 8.52    | 6.41   |
|     7 | May Hoffman           | 5.51    | 2.40   |
|     8 | Heidi F. Lawson       | 8.37    | 1.42   |
|     9 | Isaac U. Herring      | 6.85    | 1.93   |
|    10 | Amanda Roberson       | 5.97    | 9.47   |
|    11 | Oren M. Tanner        | 4.05    | 9.96   |
|    12 | Wyatt Becker          | 2.81    | 2.81   |
+-------+-----------------------+---------+--------+
12 rows in set (0.00 sec)

Dissecando o comando:

  1. SET @n = 0; — define a variável @n com o valor 0.
  2. SELECT @n := @n+1 AS ordem, nome, credito, debito FROM minhaTabela; — a segunda linha de comando é a responsável pela confecção e exibição da lista.

Se você gostaria de entender melhor o uso de variáveis no MySQL, leia este tutorial.