MySQL - Guia rápido

O que é um banco de dados?

Um banco de dados é um aplicativo separado que armazena uma coleção de dados. Cada banco de dados possui uma ou mais APIs distintas para criar, acessar, gerenciar, pesquisar e replicar os dados que contém.

Outros tipos de armazenamento de dados também podem ser usados, como arquivos no sistema de arquivos ou grandes tabelas hash na memória, mas a busca e a gravação de dados não seriam tão rápidas e fáceis com esses tipos de sistemas.

Hoje em dia, usamos sistemas de gerenciamento de banco de dados relacional (RDBMS) para armazenar e gerenciar grande volume de dados. Isso é chamado de banco de dados relacional porque todos os dados são armazenados em tabelas diferentes e as relações são estabelecidas usando chaves primárias ou outras chaves conhecidas comoForeign Keys.

UMA Relational DataBase Management System (RDBMS) é um software que -

• Permite implementar um banco de dados com tabelas, colunas e índices.

• Garante a integridade referencial entre linhas de várias tabelas.

• Atualiza os índices automaticamente.

• Interpreta uma consulta SQL e combina informações de várias tabelas.

Terminologia RDBMS

Antes de prosseguirmos com a explicação do sistema de banco de dados MySQL, vamos revisar algumas definições relacionadas ao banco de dados.

• Database - Um banco de dados é uma coleção de tabelas, com dados relacionados.

• Table- Uma tabela é uma matriz com dados. Uma tabela em um banco de dados parece uma planilha simples.

• Column - Uma coluna (elemento de dados) contém dados do mesmo tipo, por exemplo, o código postal da coluna.

• Row - Uma linha (= tupla, entrada ou registro) é um grupo de dados relacionados, por exemplo, os dados de uma assinatura.

• Redundancy - Armazenamento de dados duas vezes, de forma redundante para tornar o sistema mais rápido.

• Primary Key- Uma chave primária é única. Um valor-chave não pode ocorrer duas vezes em uma tabela. Com uma chave, você só pode encontrar uma linha.

• Foreign Key - Uma chave estrangeira é o pino de ligação entre duas tabelas.

• Compound Key - Uma chave composta (chave composta) é uma chave que consiste em várias colunas, porque uma coluna não é suficientemente exclusiva.

• Index - Um índice em um banco de dados é semelhante a um índice no final de um livro.

• Referential Integrity - Integridade referencial garante que um valor de chave estrangeira sempre aponte para uma linha existente.

Banco de dados MySQL

MySQL é um RDBMS rápido e fácil de usar, sendo usado por muitas pequenas e grandes empresas. O MySQL é desenvolvido, comercializado e suportado pela MySQL AB, que é uma empresa sueca. O MySQL está se tornando tão popular por vários bons motivos -

• O MySQL é lançado sob uma licença de código aberto. Então você não tem que pagar para usá-lo.

• O MySQL é um programa muito poderoso por si só. Ele lida com um grande subconjunto de funcionalidade dos pacotes de banco de dados mais caros e poderosos.

• O MySQL usa uma forma padrão da conhecida linguagem de dados SQL.

• MySQL funciona em muitos sistemas operacionais e com muitas linguagens, incluindo PHP, PERL, C, C ++, JAVA, etc.

• O MySQL funciona muito rapidamente e funciona bem mesmo com grandes conjuntos de dados.

• O MySQL é muito amigável ao PHP, a linguagem mais apreciada para desenvolvimento web.

• O MySQL oferece suporte a grandes bancos de dados, até 50 milhões de linhas ou mais em uma tabela. O limite de tamanho de arquivo padrão para uma tabela é de 4 GB, mas você pode aumentá-lo (se seu sistema operacional puder lidar com isso) para um limite teórico de 8 milhões de terabytes (TB).

• O MySQL é personalizável. A licença GPL de código aberto permite que os programadores modifiquem o software MySQL para se adequar a seus próprios ambientes específicos.

Antes de você começar

Antes de iniciar este tutorial, você deve ter um conhecimento básico das informações abordadas em nossos tutoriais de PHP e HTML.

Este tutorial se concentra fortemente no uso do MySQL em um ambiente PHP. Muitos exemplos dados neste tutorial serão úteis para programadores de PHP.

Recomendamos que você verifique nosso Tutorial de PHP para sua referência.

Todos os downloads do MySQL estão localizados em Downloads do MySQL . Escolha o número da versão deMySQL Community Server que é necessário junto com a plataforma em que você o executará.

Instalação do MySQL no Linux / UNIX

A maneira recomendada de instalar o MySQL em um sistema Linux é via RPM. MySQL AB disponibiliza os seguintes RPMs para download em seu site -

• MySQL - O servidor de banco de dados MySQL gerencia os bancos de dados e tabelas, controla o acesso do usuário e processa as consultas SQL.

• MySQL-client - Programas cliente MySQL, que possibilitam a conexão e a interação com o servidor.

• MySQL-devel - Bibliotecas e arquivos de cabeçalho que são úteis ao compilar outros programas que usam MySQL.

• MySQL-shared - Bibliotecas compartilhadas para o cliente MySQL.

• MySQL-bench - Ferramentas de benchmark e teste de desempenho para o servidor de banco de dados MySQL.

Os RPMs do MySQL listados aqui são todos construídos em um SuSE Linux system, mas geralmente funcionam em outras variantes do Linux sem dificuldade.

Agora, você precisará seguir as etapas fornecidas abaixo para prosseguir com a instalação -

• Faça login no sistema usando o root do utilizador.

• Mude para o diretório que contém os RPMs.

• Instale o servidor de banco de dados MySQL executando o seguinte comando. Lembre-se de substituir o nome do arquivo em itálico pelo nome do arquivo do seu RPM.

[root@host]# rpm -i MySQL-5.0.9-0.i386.rpm

O comando acima cuida da instalação do servidor MySQL, criando um usuário do MySQL, criando a configuração necessária e iniciando o servidor MySQL automaticamente.

Você pode encontrar todos os binários relacionados ao MySQL em / usr / bin e / usr / sbin. Todas as tabelas e bancos de dados serão criados no diretório / var / lib / mysql.

A caixa de código a seguir tem uma etapa opcional, mas recomendada para instalar os RPMs restantes da mesma maneira -

[root@host]# rpm -i MySQL-client-5.0.9-0.i386.rpm
[root@host]# rpm -i MySQL-devel-5.0.9-0.i386.rpm
[root@host]# rpm -i MySQL-shared-5.0.9-0.i386.rpm
[root@host]# rpm -i MySQL-bench-5.0.9-0.i386.rpm

Instalando MySQL no Windows

A instalação padrão em qualquer versão do Windows agora é muito mais fácil do que costumava ser, já que o MySQL agora vem perfeitamente empacotado com um instalador. Basta baixar o pacote do instalador, descompactá-lo em qualquer lugar e executar o arquivo setup.exe.

O instalador padrão setup.exe irá guiá-lo através do processo trivial e, por padrão, instalará tudo em C: \ mysql.

Teste o servidor ativando-o no prompt de comando pela primeira vez. Vá para a localização domysqld server que é provavelmente C: \ mysql \ bin, e digite -

mysqld.exe --console

NOTE - Se você estiver no NT, você terá que usar mysqld-nt.exe ao invés de mysqld.exe

Se tudo correr bem, você verá algumas mensagens sobre inicialização e InnoDB. Caso contrário, você pode ter um problema de permissão. Certifique-se de que o diretório que contém seus dados seja acessível a qualquer usuário (provavelmente MySQL) sob o qual os processos de banco de dados são executados.

O MySQL não se adiciona ao menu iniciar, e também não há uma maneira GUI particularmente agradável de parar o servidor. Portanto, se você tende a iniciar o servidor clicando duas vezes no executável mysqld, deve se lembrar de interromper o processo manualmente usando mysqladmin, Lista de Tarefas, Gerenciador de Tarefas ou outros meios específicos do Windows.

Verificando a instalação do MySQL

Após o MySQL ter sido instalado com sucesso, as tabelas de base foram inicializadas e o servidor foi iniciado: você pode verificar se tudo está funcionando como deveria através de alguns testes simples.

Use o utilitário mysqladmin para obter o status do servidor

Usar mysqladminbinário para verificar a versão do servidor. Este binário estaria disponível em / usr / bin no linux e em C: \ mysql \ bin no windows.

[root@host]# mysqladmin --version

Ele produzirá o seguinte resultado no Linux. Pode variar dependendo da sua instalação -

mysqladmin  Ver 8.23 Distrib 5.0.9-0, for redhat-linux-gnu on i386

Se você não receber essa mensagem, pode haver algum problema na instalação e você precisará de ajuda para corrigi-lo.

Execute comandos SQL simples usando o cliente MySQL

Você pode se conectar ao seu servidor MySQL por meio do cliente MySQL e usando o mysqlcomando. Neste momento, você não precisa fornecer nenhuma senha, pois por padrão ela será definida como em branco.

Você pode apenas usar o seguinte comando -

[root@host]# mysql

Deve ser recompensado com um prompt mysql>. Agora, você está conectado ao servidor MySQL e pode executar todos os comandos SQL no prompt mysql> da seguinte maneira -

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
|   mysql  | 
|   test   |  
+----------+
2 rows in set (0.13 sec)

Etapas de pós-instalação

O MySQL é fornecido com uma senha em branco para o usuário raiz do MySQL. Assim que tiver instalado com sucesso o banco de dados e o cliente, você precisa definir uma senha root conforme fornecido no seguinte bloco de código -

[root@host]# mysqladmin -u root password "new_password";

Agora, para fazer uma conexão com seu servidor MySQL, você teria que usar o seguinte comando -

[root@host]# mysql -u root -p
Enter password:*******

Os usuários do UNIX também vão querer colocar seu diretório MySQL em seu PATH, então você não terá que digitar o caminho completo toda vez que quiser usar o cliente de linha de comando.

Para o bash, seria algo como -

export PATH = $PATH:/usr/bin:/usr/sbin

Executando MySQL no momento da inicialização

Se você deseja executar o servidor MySQL na hora da inicialização, certifique-se de ter a seguinte entrada no arquivo /etc/rc.local.

/etc/init.d/mysqld start

Além disso, você deve ter o binário mysqld no diretório /etc/init.d/.

Executando e desligando o servidor MySQL

Primeiro verifique se o seu servidor MySQL está funcionando ou não. Você pode usar o seguinte comando para verificar isso -

ps -ef | grep mysqld

Se o seu MySql estiver rodando, você verá mysqldprocesso listado em seu resultado. Se o servidor não estiver em execução, você pode iniciá-lo usando o seguinte comando -

root@host# cd /usr/bin
./safe_mysqld &

Agora, se você deseja desligar um servidor MySQL que já está em execução, você pode fazer isso usando o seguinte comando -

root@host# cd /usr/bin
./mysqladmin -u root -p shutdown
Enter password: ******

Configurando uma conta de usuário MySQL

Para adicionar um novo usuário ao MySQL, você só precisa adicionar uma nova entrada ao user tabela no banco de dados mysql.

O programa a seguir é um exemplo de adição de um novo usuário guest com os privilégios SELECT, INSERT e UPDATE com a senha guest123; a consulta SQL é -

root@host# mysql -u root -p
Enter password:*******
mysql> use mysql;
Database changed

mysql> INSERT INTO user 
   (host, user, password, 
   select_priv, insert_priv, update_priv) 
   VALUES ('localhost', 'guest', 
   PASSWORD('guest123'), 'Y', 'Y', 'Y');
Query OK, 1 row affected (0.20 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 1 row affected (0.01 sec)

mysql> SELECT host, user, password FROM user WHERE user = 'guest';
+-----------+---------+------------------+
|    host   |   user  |     password     |    
+-----------+---------+------------------+
| localhost |  guest  | 6f8c114b58f2ce9e |
+-----------+---------+------------------+
1 row in set (0.00 sec)

Ao adicionar um novo usuário, lembre-se de criptografar a nova senha usando a função PASSWORD () fornecida pelo MySQL. Como você pode ver no exemplo acima, a senha mypass é criptografada para 6f8c114b58f2ce9e.

Observe a instrução FLUSH PRIVILEGES. Isso diz ao servidor para recarregar as tabelas de permissões. Se você não o usar, não será capaz de se conectar ao MySQL usando a nova conta de usuário pelo menos até que o servidor seja reinicializado.

Você também pode especificar outros privilégios para um novo usuário, definindo os valores das seguintes colunas na tabela do usuário para 'Y' ao executar a consulta INSERT ou você pode atualizá-los posteriormente usando a consulta UPDATE.

• Select_priv
• Insert_priv
• Update_priv
• Delete_priv
• Create_priv
• Drop_priv
• Reload_priv
• Shutdown_priv
• Process_priv
• File_priv
• Grant_priv
• References_priv
• Index_priv
• Alter_priv

Outra maneira de adicionar conta de usuário é usando o comando GRANT SQL. O exemplo a seguir irá adicionar usuáriozara com senha zara123 para um banco de dados específico, que é nomeado como TUTORIALS.

root@host# mysql -u root -p password;
Enter password:*******
mysql> use mysql;
Database changed

mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
   -> ON TUTORIALS.*
   -> TO 'zara'@'localhost'
   -> IDENTIFIED BY 'zara123';

Isso também criará uma entrada na tabela do banco de dados MySQL chamada de user.

NOTE - O MySQL não termina um comando até que você coloque um ponto e vírgula (;) no final do comando SQL.

A configuração do arquivo /etc/my.cnf

Na maioria dos casos, você não deve tocar neste arquivo. Por padrão, ele terá as seguintes entradas -

[mysqld]
datadir = /var/lib/mysql
socket = /var/lib/mysql/mysql.sock

[mysql.server]
user = mysql
basedir = /var/lib

[safe_mysqld]
err-log = /var/log/mysqld.log
pid-file = /var/run/mysqld/mysqld.pid

Aqui, você pode especificar um diretório diferente para o log de erros, caso contrário, você não deve alterar nenhuma entrada nesta tabela.

Comando administrativo do MySQL

Aqui está a lista dos comandos MySQL importantes, que você usará de vez em quando para trabalhar com o banco de dados MySQL -

• USE Databasename - Isso será usado para selecionar um banco de dados na área de trabalho do MySQL.

• SHOW DATABASES - Lista os bancos de dados que podem ser acessados ​​pelo DBMS MySQL.

• SHOW TABLES - Mostra as tabelas no banco de dados, uma vez que um banco de dados foi selecionado com o comando use.

• SHOW COLUMNS FROM tablename: Mostra os atributos, tipos de atributos, informações chave, se NULL é permitido, padrões e outras informações para uma tabela.

• SHOW INDEX FROM tablename - Apresenta os detalhes de todos os índices da tabela, incluindo a CHAVE PRIMÁRIA.

• SHOW TABLE STATUS LIKE tablename\G - Relata detalhes do desempenho e estatísticas do MySQL DBMS.

No próximo capítulo, discutiremos como a sintaxe do PHP é usada no MySQL.

O MySQL funciona muito bem em combinação de várias linguagens de programação como PERL, C, C ++, JAVA e PHP. Dentre essas linguagens, PHP é a mais popular por causa de seus recursos de desenvolvimento de aplicativos da web.

Este tutorial se concentra fortemente no uso do MySQL em um ambiente PHP. Se você está interessado no MySQL com PERL, então você pode considerar a leitura do Tutorial PERL .

O PHP fornece várias funções para acessar o banco de dados MySQL e manipular os registros de dados dentro do banco de dados MySQL. Você precisaria chamar as funções PHP da mesma maneira que chama qualquer outra função PHP.

As funções PHP para uso com MySQL têm o seguinte formato geral -

mysql_function(value,value,...);

A segunda parte do nome da função é específica para a função, geralmente uma palavra que descreve o que a função faz. A seguir estão duas das funções, que usaremos em nosso tutorial -

mysqli_connect($connect);
mysqli_query($connect,"SQL statement");

O exemplo a seguir mostra uma sintaxe genérica de PHP para chamar qualquer função MySQL.

<html>
   <head>
      <title>PHP with MySQL</title>
   </head>
   
   <body>
      <?php
         $retval = mysql_function(value, [value,...]);
         if( !$retval ) {
            die ( "Error: a related error message" );
         }
         // Otherwise MySQL  or PHP Statements
      ?>
   </body>
</html>

A partir do próximo capítulo, veremos todas as funcionalidades importantes do MySQL junto com o PHP.

Conexão MySQL usando o binário MySQL

Você pode estabelecer o banco de dados MySQL usando o mysql binário no prompt de comando.

Exemplo

Aqui está um exemplo simples para se conectar ao servidor MySQL a partir do prompt de comando -

[root@host]# mysql -u root -p
Enter password:******

Isso lhe dará o prompt de comando mysql> onde você poderá executar qualquer comando SQL. A seguir está o resultado do comando acima -

O seguinte bloco de código mostra o resultado do código acima -

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2854760 to server version: 5.0.9

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

No exemplo acima, usamos rootcomo um usuário, mas você pode usar qualquer outro usuário também. Qualquer usuário poderá realizar todas as operações SQL permitidas a esse usuário.

Você pode se desconectar do banco de dados MySQL a qualquer momento usando o exit comando no prompt mysql>.

mysql> exit
Bye

Conexão MySQL usando script PHP

PHP fornece mysql_connect()função para abrir uma conexão de banco de dados. Esta função recebe cinco parâmetros e retorna um identificador de link MySQL em caso de sucesso ou FALSE em caso de falha.

Sintaxe

connection mysql_connect(server,user,passwd,new_link,client_flag);

Sr. Não.	Parâmetro e Descrição
1	server Opcional - o nome do host que executa o servidor de banco de dados. Se não for especificado, o valor padrão serálocalhost:3306.
2	user Opcional - o nome de usuário que acessa o banco de dados. Se não for especificado, o padrão será o nome do usuário que possui o processo do servidor.
3	passwd Opcional - A senha do usuário que acessa o banco de dados. Se não for especificado, o padrão será uma senha vazia.
4	new_link Opcional - Se uma segunda chamada for feita para mysql_connect () com os mesmos argumentos, nenhuma nova conexão será estabelecida; em vez disso, o identificador da conexão já aberta será retornado.
5	client_flags Opcional - uma combinação das seguintes constantes - MYSQL_CLIENT_SSL - Use criptografia SSL. MYSQL_CLIENT_COMPRESS - Use o protocolo de compressão. MYSQL_CLIENT_IGNORE_SPACE - Deixe espaço após os nomes das funções. MYSQL_CLIENT_INTERACTIVE - Permite tempo limite interativo em segundos de inatividade antes de fechar a conexão.

Você pode se desconectar do banco de dados MySQL a qualquer momento usando outra função PHP mysql_close(). Esta função leva um único parâmetro, que é uma conexão retornada pelomysql_connect() função.

Sintaxe

bool mysql_close ( resource $link_identifier );

Se um recurso não for especificado, o último banco de dados aberto será fechado. Esta função retorna verdadeiro se fechar a conexão com sucesso, caso contrário, retorna falso.

Exemplo

Tente o seguinte exemplo para se conectar a um servidor MySQL -

<html>
   <head>
      <title>Connecting MySQL Server</title>
   </head>
   <body>
      <?php
         $dbhost = 'localhost:3306'; $dbuser = 'guest';
         $dbpass = 'guest123'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully';
         mysql_close($conn);
      ?>
   </body>
</html>

Criar banco de dados usando mysqladmin

Você precisaria de privilégios especiais para criar ou excluir um banco de dados MySQL. Então, supondo que você tenha acesso ao usuário root, você pode criar qualquer banco de dados usando o mysqlmysqladmin binário.

Exemplo

Aqui está um exemplo simples para criar um banco de dados chamado TUTORIALS -

[root@host]# mysqladmin -u root -p create TUTORIALS
Enter password:******

Isso criará um banco de dados MySQL chamado TUTORIALS.

Crie um banco de dados usando PHP Script

PHP usa mysql_queryfunção para criar ou excluir um banco de dados MySQL. Esta função recebe dois parâmetros e retorna TRUE em caso de sucesso ou FALSE em caso de falha.

Sintaxe

bool mysql_query( sql, connection );

Sr. Não.	Parâmetro e Descrição
1	sql Obrigatório - consulta SQL para criar ou excluir um banco de dados MySQL
2	connection Opcional - se não for especificado, a última conexão aberta por mysql_connect será usada.

Exemplo

O exemplo a seguir para criar um banco de dados -

<html>
   <head>
      <title>Creating MySQL Database</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = 'CREATE DATABASE TUTORIALS';
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not create database: ' . mysql_error());
         }
         echo "Database TUTORIALS created successfully\n";
         mysql_close($conn);
      ?>
   </body>
</html>

Eliminar um banco de dados usando mysqladmin

Você precisaria de privilégios especiais para criar ou excluir um banco de dados MySQL. Então, supondo que você tenha acesso ao usuário root, você pode criar qualquer banco de dados usando o mysqlmysqladmin binário.

Tenha cuidado ao excluir qualquer banco de dados porque você perderá todos os dados disponíveis em seu banco de dados.

Aqui está um exemplo para excluir um banco de dados (TUTORIAIS) criado no capítulo anterior -

[root@host]# mysqladmin -u root -p drop TUTORIALS
Enter password:******

Isso lhe dará um aviso e confirmará se você realmente deseja excluir este banco de dados ou não.

Dropping the database is potentially a very bad thing to do.
Any data stored in the database will be destroyed.

Do you really want to drop the 'TUTORIALS' database [y/N] y
Database "TUTORIALS" dropped

Eliminar banco de dados usando script PHP

PHP usa mysql_queryfunção para criar ou excluir um banco de dados MySQL. Esta função recebe dois parâmetros e retorna TRUE em caso de sucesso ou FALSE em caso de falha.

Sintaxe

bool mysql_query( sql, connection );

Sr. Não	Parâmetro e Descrição
1	sql Obrigatório - consulta SQL para criar ou excluir um banco de dados MySQL
2	connection Opcional - se não for especificado, a última conexão aberta por mysql_connect será usada.

Exemplo

Tente o seguinte exemplo para excluir um banco de dados -

<html>
   <head>
      <title>Deleting MySQL Database</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = 'DROP DATABASE TUTORIALS';
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not delete database: ' . mysql_error());
         }
         echo "Database TUTORIALS deleted successfully\n";
         mysql_close($conn);
      ?>
   </body>
</html>

WARNING- Ao excluir um banco de dados usando o script PHP, ele não solicita nenhuma confirmação. Portanto, tome cuidado ao excluir um banco de dados MySQL.

Depois de se conectar ao servidor MySQL, é necessário selecionar um banco de dados com o qual trabalhar. Isso ocorre porque pode haver mais de um banco de dados disponível com o servidor MySQL.

Seleção do banco de dados MySQL no prompt de comando

É muito simples selecionar um banco de dados no prompt mysql>. Você pode usar o comando SQLuse para selecionar um banco de dados.

Exemplo

Aqui está um exemplo para selecionar um banco de dados chamado TUTORIALS -

[root@host]# mysql -u root -p
Enter password:******
mysql> use TUTORIALS;
Database changed
mysql>

Agora, você selecionou o banco de dados TUTORIALS e todas as operações subsequentes serão realizadas no banco de dados TUTORIALS.

NOTE- Todos os nomes de banco de dados, nomes de tabela, nome de campos de tabela diferenciam maiúsculas de minúsculas. Portanto, você teria que usar os nomes próprios ao fornecer qualquer comando SQL.

Selecionando um banco de dados MySQL usando script PHP

PHP fornece função mysql_select_dbpara selecionar um banco de dados. Ele retorna TRUE em caso de sucesso ou FALSE em caso de falha.

Sintaxe

bool mysql_select_db( db_name, connection );

Sr. Não.	Parâmetro e Descrição
1	db_name Obrigatório - nome do banco de dados MySQL a ser selecionado
2	connection Opcional - se não for especificado, a última conexão aberta por mysql_connect será usada.

Exemplo

Aqui está um exemplo que mostra como selecionar um banco de dados.

<html>
   <head>
      <title>Selecting MySQL Database</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'guest'; $dbpass = 'guest123';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully'; mysql_select_db( 'TUTORIALS' ); mysql_close($conn);
      ?>
   </body>
</html>

Definir adequadamente os campos em uma tabela é importante para a otimização geral do seu banco de dados. Você deve usar apenas o tipo e o tamanho do campo que realmente precisa usar. Por exemplo, não defina um campo de 10 caracteres de largura, se você sabe que usará apenas 2 caracteres. Esses tipos de campos (ou colunas) também são chamados de tipos de dados, após otype of data você estará armazenando nesses campos.

O MySQL usa muitos tipos de dados diferentes divididos em três categorias -

• Numeric
• Data e hora
• Tipos de string.

Vamos agora discuti-los em detalhes.

Tipos de dados numéricos

O MySQL usa todos os tipos de dados numéricos ANSI SQL padrão, portanto, se você estiver chegando ao MySQL de um sistema de banco de dados diferente, essas definições parecerão familiares para você.

A lista a seguir mostra os tipos de dados numéricos comuns e suas descrições -

• INT- Um número inteiro de tamanho normal que pode ser assinado ou não assinado. Se assinado, o intervalo permitido é de -2147483648 a 2147483647. Se não assinado, o intervalo permitido é de 0 a 4294967295. Você pode especificar uma largura de até 11 dígitos.

• TINYINT- Um número inteiro muito pequeno que pode ser assinado ou não assinado. Se assinado, o intervalo permitido é de -128 a 127. Se não assinado, o intervalo permitido é de 0 a 255. Você pode especificar uma largura de até 4 dígitos.

• SMALLINT- Um pequeno número inteiro que pode ser assinado ou não assinado. Se assinado, o intervalo permitido é de -32768 a 32767. Se não assinado, o intervalo permitido é de 0 a 65535. Você pode especificar uma largura de até 5 dígitos.

• MEDIUMINT- Um inteiro de tamanho médio que pode ser assinado ou não assinado. Se assinado, o intervalo permitido é de -8388608 a 8388607. Se não assinado, o intervalo permitido é de 0 a 16777215. Você pode especificar uma largura de até 9 dígitos.

• BIGINT- Um grande número inteiro que pode ser assinado ou não assinado. Se assinado, o intervalo permitido é de -9223372036854775808 a 9223372036854775807. Se não assinado, o intervalo permitido é de 0 a 18446744073709551615. Você pode especificar uma largura de até 20 dígitos.

• FLOAT(M,D)- Um número de ponto flutuante que não pode ser sem sinal. Você pode definir o comprimento de exibição (M) e o número de decimais (D). Isso não é obrigatório e o padrão é 10,2, onde 2 é o número de decimais e 10 é o número total de dígitos (incluindo decimais). A precisão decimal pode chegar a 24 casas para um FLOAT.

• DOUBLE(M,D)- Um número de ponto flutuante de precisão dupla que não pode ser sem sinal. Você pode definir o comprimento de exibição (M) e o número de decimais (D). Isso não é obrigatório e o padrão é 16,4, onde 4 é o número de decimais. A precisão decimal pode chegar a 53 casas para um DOUBLE. REAL é sinônimo de DOUBLE.

• DECIMAL(M,D)- Um número de ponto flutuante descompactado que não pode ser sem sinal. Nos decimais não compactados, cada decimal corresponde a um byte. É necessário definir o comprimento de exibição (M) e o número de decimais (D). NUMERIC é sinônimo de DECIMAL.

Tipos de data e hora

Os tipos de dados de data e hora do MySQL são os seguintes -

• DATE- Uma data no formato AAAA-MM-DD, entre 1000-01-01 e 9999-12-31. Por exemplo, 30 de Dezembro ^th de 1973 seria armazenado como 1973/12/30.

• DATETIME- Uma combinação de data e hora no formato AAAA-MM-DD HH: MM: SS, entre 1000-01-01 00:00:00 e 9999-12-31 23:59:59. Por exemplo, 3:30 da tarde de 30 de dezembro ^th de 1973 seria armazenado como 1973/12/30 15:30:00.

• TIMESTAMP- Um timestamp entre meia-noite, 01 de janeiro ^st , 1970 e em algum momento de 2037. Isto parece o formato DATETIME anterior, só que sem os hífens entre números; 3:30 da tarde de 30 de dezembro ^th de 1973 seria armazenado como 19731230153000 (YYYYMMDDHHMMSS).

• TIME - Armazena a hora no formato HH: MM: SS.

• YEAR(M)- Armazena um ano no formato de 2 ou 4 dígitos. Se o comprimento for especificado como 2 (por exemplo, ANO (2)), ANO pode ser entre 1970 a 2069 (70 a 69). Se o comprimento for especificado como 4, ANO pode ser de 1901 a 2155. O comprimento padrão é 4.

Tipos de String

Embora os tipos numéricos e de data sejam divertidos, a maioria dos dados que você armazenará estarão em formato de string. Esta lista descreve os tipos de dados de string comuns no MySQL.

• CHAR(M)- Uma string de comprimento fixo entre 1 e 255 caracteres (por exemplo CHAR (5)), preenchida à direita com espaços para o comprimento especificado quando armazenado. Definir um comprimento não é obrigatório, mas o padrão é 1.

• VARCHAR(M)- Uma string de comprimento variável entre 1 e 255 caracteres. Por exemplo, VARCHAR (25). Você deve definir um comprimento ao criar um campo VARCHAR.

• BLOB or TEXT- Um campo com comprimento máximo de 65535 caracteres. BLOBs são "Objetos Binários Grandes" e são usados ​​para armazenar grandes quantidades de dados binários, como imagens ou outros tipos de arquivos. Os campos definidos como TEXTO também contêm grandes quantidades de dados. A diferença entre os dois é que as classificações e comparações nos dados armazenados sãocase sensitive em BLOBs e são not case sensitivenos campos TEXT. Você não especifica um comprimento com BLOB ou TEXT.

• TINYBLOB or TINYTEXT- Uma coluna BLOB ou TEXT com comprimento máximo de 255 caracteres. Você não especifica um comprimento com TINYBLOB ou TINYTEXT.

• MEDIUMBLOB or MEDIUMTEXT- Uma coluna BLOB ou TEXT com comprimento máximo de 16777215 caracteres. Você não especifica um comprimento com MEDIUMBLOB ou MEDIUMTEXT.

• LONGBLOB or LONGTEXT- Uma coluna BLOB ou TEXT com comprimento máximo de 4294967295 caracteres. Você não especifica um comprimento com LONGBLOB ou LONGTEXT.

• ENUM- Uma enumeração, que é um termo sofisticado para lista. Ao definir um ENUM, você está criando uma lista de itens a partir dos quais o valor deve ser selecionado (ou pode ser NULL). Por exemplo, se você quiser que seu campo contenha "A" ou "B" ou "C", você deve definir seu ENUM como ENUM ('A', 'B', 'C') e apenas esses valores (ou NULL) poderia preencher esse campo.

No próximo capítulo, discutiremos como criar tabelas no MySQL.

Para começar, o comando de criação de tabela requer os seguintes detalhes -

• Nome da mesa
• Nome dos campos
• Definições para cada campo

Sintaxe

Aqui está uma sintaxe SQL genérica para criar uma tabela MySQL -

CREATE TABLE table_name (column_name column_type);

Agora, vamos criar a seguinte tabela no TUTORIALS base de dados.

create table tutorials_tbl(
   tutorial_id INT NOT NULL AUTO_INCREMENT,
   tutorial_title VARCHAR(100) NOT NULL,
   tutorial_author VARCHAR(40) NOT NULL,
   submission_date DATE,
   PRIMARY KEY ( tutorial_id )
);

Aqui, alguns itens precisam de explicação -

• Atributo de campo NOT NULLestá sendo usado porque não queremos que este campo seja NULL. Portanto, se um usuário tentar criar um registro com um valor NULL, o MySQL gerará um erro.

• Atributo de campo AUTO_INCREMENT diz ao MySQL para prosseguir e adicionar o próximo número disponível ao campo id.

• Palavra-chave PRIMARY KEYé usado para definir uma coluna como uma chave primária. Você pode usar várias colunas separadas por uma vírgula para definir uma chave primária.

Criação de tabelas a partir do prompt de comando

É fácil criar uma tabela MySQL a partir do prompt mysql>. Você usará o comando SQLCREATE TABLE para criar uma mesa.

Exemplo

Aqui está um exemplo, que irá criar tutorials_tbl -

root@host# mysql -u root -p
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> CREATE TABLE tutorials_tbl(
   -> tutorial_id INT NOT NULL AUTO_INCREMENT,
   -> tutorial_title VARCHAR(100) NOT NULL,
   -> tutorial_author VARCHAR(40) NOT NULL,
   -> submission_date DATE,
   -> PRIMARY KEY ( tutorial_id )
   -> );
Query OK, 0 rows affected (0.16 sec)
mysql>

NOTE - O MySQL não termina um comando até que você forneça um ponto-e-vírgula (;) no final do comando SQL.

Criação de tabelas usando script PHP

Para criar uma nova tabela em qualquer banco de dados existente, você precisará usar a função PHP mysql_query(). Você passará seu segundo argumento com um comando SQL apropriado para criar uma tabela.

Exemplo

O programa a seguir é um exemplo para criar uma tabela usando script PHP -

<html>
   <head>
      <title>Creating MySQL Tables</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully<br />';
         $sql = "CREATE TABLE tutorials_tbl( ". "tutorial_id INT NOT NULL AUTO_INCREMENT, ". "tutorial_title VARCHAR(100) NOT NULL, ". "tutorial_author VARCHAR(40) NOT NULL, ". "submission_date DATE, ". "PRIMARY KEY ( tutorial_id )); "; mysql_select_db( 'TUTORIALS' ); $retval = mysql_query( $sql, $conn );
         
         if(! $retval ) { die('Could not create table: ' . mysql_error()); } echo "Table created successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

É muito fácil eliminar uma tabela MySQL existente, mas você precisa ter muito cuidado ao excluir qualquer tabela existente, pois os dados perdidos não serão recuperados após a exclusão de uma tabela.

Sintaxe

Aqui está uma sintaxe SQL genérica para descartar uma tabela MySQL -

DROP TABLE table_name ;

Eliminando tabelas do prompt de comando

Para eliminar tabelas do prompt de comando, precisamos executar o comando DROP TABLE SQL no prompt mysql>.

Exemplo

O programa a seguir é um exemplo que exclui o tutorials_tbl -

root@host# mysql -u root -p
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> DROP TABLE tutorials_tbl
Query OK, 0 rows affected (0.8 sec)
mysql>

Eliminando tabelas usando script PHP

Para eliminar uma tabela existente em qualquer banco de dados, você precisaria usar a função PHP mysql_query(). Você passará seu segundo argumento com um comando SQL apropriado para eliminar uma tabela.

Exemplo

<html>
   <head>
      <title>Creating MySQL Tables</title>
   </head>
   
   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully<br />';
         $sql = "DROP TABLE tutorials_tbl"; mysql_select_db( 'TUTORIALS' ); $retval = mysql_query( $sql, $conn );
         
         if(! $retval ) { die('Could not delete table: ' . mysql_error()); } echo "Table deleted successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

Para inserir dados em uma tabela MySQL, você precisaria usar o SQL INSERT INTOcomando. Você pode inserir dados na tabela MySQL usando o prompt mysql> ou usando qualquer script como PHP.

Sintaxe

Aqui está uma sintaxe SQL genérica do comando INSERT INTO para inserir dados na tabela MySQL -

INSERT INTO table_name ( field1, field2,...fieldN )
   VALUES
   ( value1, value2,...valueN );

Para inserir tipos de dados de string, é necessário manter todos os valores entre aspas duplas ou simples. Por exemplo"value".

Inserindo dados do prompt de comando

Para inserir dados do prompt de comando, usaremos o comando SQL INSERT INTO para inserir dados na tabela tutorials_tbl do MySQL.

Exemplo

O exemplo a seguir criará 3 registros em tutorials_tbl mesa -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed

mysql> INSERT INTO tutorials_tbl 
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("Learn PHP", "John Poul", NOW());
Query OK, 1 row affected (0.01 sec)

mysql> INSERT INTO tutorials_tbl
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("Learn MySQL", "Abdul S", NOW());
Query OK, 1 row affected (0.01 sec)

mysql> INSERT INTO tutorials_tbl
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("JAVA Tutorial", "Sanjay", '2007-05-06');
Query OK, 1 row affected (0.01 sec)
mysql>

NOTE- Observe que todos os sinais de seta (->) não fazem parte do comando SQL. Eles estão indicando uma nova linha e são criados automaticamente pelo prompt do MySQL enquanto pressiona a tecla enter sem fornecer um ponto-e-vírgula no final de cada linha do comando.

No exemplo acima, não fornecemos um tutorial_id porque, no momento da criação da tabela, demos a opção AUTO_INCREMENT para este campo. Portanto, o MySQL se encarrega de inserir esses IDs automaticamente. Aqui,NOW() é uma função MySQL, que retorna a data e hora atuais.

Inserindo dados usando um script PHP

Você pode usar o mesmo comando SQL INSERT INTO na função PHP mysql_query() para inserir dados em uma tabela MySQL.

Exemplo

Este exemplo pegará três parâmetros do usuário e os inserirá na tabela MySQL -

<html>

   <head>
      <title>Add New Record in MySQL Database</title>
   </head>

   <body>
      <?php
         if(isset($_POST['add'])) { $dbhost = 'localhost:3036';
            $dbuser = 'root'; $dbpass = 'rootpassword';
            $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
            if(! $conn ) { die('Could not connect: ' . mysql_error()); } if(! get_magic_quotes_gpc() ) { $tutorial_title = addslashes ($_POST['tutorial_title']); $tutorial_author = addslashes ($_POST['tutorial_author']); } else { $tutorial_title = $_POST['tutorial_title']; $tutorial_author = $_POST['tutorial_author']; } $submission_date = $_POST['submission_date']; $sql = "INSERT INTO tutorials_tbl ".
               "(tutorial_title,tutorial_author, submission_date) "."VALUES ".
               "('$tutorial_title','$tutorial_author','$submission_date')"; mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
         
            if(! $retval ) { die('Could not enter data: ' . mysql_error()); } echo "Entered data successfully\n"; mysql_close($conn);
         } else {
      ?>
   
      <form method = "post" action = "<?php $_PHP_SELF ?>">
         <table width = "600" border = "0" cellspacing = "1" cellpadding = "2">
            <tr>
               <td width = "250">Tutorial Title</td>
               <td>
                  <input name = "tutorial_title" type = "text" id = "tutorial_title">
               </td>
            </tr>
         
            <tr>
               <td width = "250">Tutorial Author</td>
               <td>
                  <input name = "tutorial_author" type = "text" id = "tutorial_author">
               </td>
            </tr>
         
            <tr>
               <td width = "250">Submission Date [   yyyy-mm-dd ]</td>
               <td>
                  <input name = "submission_date" type = "text" id = "submission_date">
               </td>
            </tr>
      
            <tr>
               <td width = "250"> </td>
               <td> </td>
            </tr>
         
            <tr>
               <td width = "250"> </td>
               <td>
                  <input name = "add" type = "submit" id = "add"  value = "Add Tutorial">
               </td>
            </tr>
         </table>
      </form>
   <?php
      }
   ?>
   </body>
</html>

Ao fazer uma inserção de dados, é melhor usar a função get_magic_quotes_gpc()para verificar se a configuração atual para aspas mágicas está definida ou não. Se esta função retornar falso, use a funçãoaddslashes() para adicionar barras antes das aspas.

Você pode colocar várias validações para verificar se os dados inseridos estão corretos ou não e pode tomar a ação apropriada.

O SQL SELECTcomando é usado para buscar dados do banco de dados MySQL. Você pode usar este comando no prompt mysql> assim como em qualquer script como PHP.

Sintaxe

Aqui está a sintaxe SQL genérica do comando SELECT para buscar dados da tabela MySQL -

SELECT field1, field2,...fieldN 
FROM table_name1, table_name2...
[WHERE Clause]
[OFFSET M ][LIMIT N]

• Você pode usar uma ou mais tabelas separadas por vírgula para incluir várias condições usando uma cláusula WHERE, mas a cláusula WHERE é uma parte opcional do comando SELECT.

• Você pode buscar um ou mais campos em um único comando SELECT.

• Você pode especificar asterisco (*) no lugar dos campos. Nesse caso, SELECT retornará todos os campos.

• Você pode especificar qualquer condição usando a cláusula WHERE.

• Você pode especificar um deslocamento usando OFFSETde onde SELECT começará a retornar registros. Por padrão, o deslocamento começa em zero.

• Você pode limitar o número de devoluções usando o LIMIT atributo.

Buscando dados de um prompt de comando

Isso usará o comando SQL SELECT para buscar dados da tabela MySQL tutorials_tbl.

Exemplo

O exemplo a seguir retornará todos os registros do tutorials_tbl mesa -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl 
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|           1 | Learn PHP      | John Poul       | 2007-05-21      |
|           2 | Learn MySQL    | Abdul S         | 2007-05-21      |
|           3 | JAVA Tutorial  | Sanjay          | 2007-05-21      |
+-------------+----------------+-----------------+-----------------+
3 rows in set (0.01 sec)

mysql>

Buscando dados usando um script PHP

Você pode usar o mesmo comando SQL SELECT em uma função PHP mysql_query(). Esta função é usada para executar o comando SQL e depois outra função PHPmysql_fetch_array()pode ser usado para buscar todos os dados selecionados. Esta função retorna a linha como uma matriz associativa, uma matriz numérica ou ambos. Esta função retorna FALSE se não houver mais linhas.

O programa a seguir é um exemplo simples que mostrará como buscar / exibir registros do tutorials_tbl mesa.

Exemplo

O bloco de código a seguir exibirá todos os registros da tabela tutorials_tbl.

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT tutorial_id, tutorial_title, tutorial_author, submission_date FROM tutorials_tbl';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }
   
   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Tutorial ID :{$row['tutorial_id']} <br> ". "Title: {$row['tutorial_title']} <br> ".
         "Author: {$row['tutorial_author']} <br> ". "Submission Date : {$row['submission_date']} <br> ".
         "--------------------------------<br>";
   } 
   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

O conteúdo das linhas é atribuído à variável $ row e os valores dessa linha são impressos.

NOTE - Lembre-se sempre de colocar colchetes quando quiser inserir um valor de array diretamente em uma string.

No exemplo acima, a constante MYSQL_ASSOC é usado como o segundo argumento para a função PHP mysql_fetch_array(), para que ele retorne a linha como uma matriz associativa. Com uma matriz associativa, você pode acessar o campo usando seu nome em vez de usar o índice.

PHP fornece outra função chamada mysql_fetch_assoc(), que também retorna a linha como uma matriz associativa.

Exemplo

O exemplo a seguir para exibir todos os registros da tabela tutorial_tbl usando a função mysql_fetch_assoc ().

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }
   
   $sql = 'SELECT tutorial_id, tutorial_title, tutorial_author, submission_date FROM tutorials_tbl'; mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_assoc($retval)) { echo "Tutorial ID :{$row['tutorial_id']}  <br> ".
         "Title: {$row['tutorial_title']} <br> ". "Author: {$row['tutorial_author']} <br> ".
         "Submission Date : {$row['submission_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Você também pode usar a constante MYSQL_NUMcomo o segundo argumento para a função PHP mysql_fetch_array (). Isso fará com que a função retorne um array com o índice numérico.

Exemplo

Experimente o seguinte exemplo para exibir todos os registros da tabela tutorials_tbl usando o argumento MYSQL_NUM.

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }
   
   $sql = 'SELECT tutorial_id, tutorial_title, tutorial_author, submission_date FROM tutorials_tbl'; mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_NUM)) { echo "Tutorial ID :{$row[0]}  <br> ".
         "Title: {$row[1]} <br> ". "Author: {$row[2]} <br> ".
         "Submission Date : {$row[3]} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Todos os três exemplos acima produzirão o mesmo resultado.

Liberando Memória

É uma boa prática liberar a memória do cursor no final de cada instrução SELECT. Isso pode ser feito usando a função PHPmysql_free_result(). O programa a seguir é um exemplo para mostrar como deve ser usado.

Exemplo

Experimente o seguinte exemplo -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }
   
   $sql = 'SELECT tutorial_id, tutorial_title, tutorial_author, submission_date FROM tutorials_tbl'; mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_NUM)) { echo "Tutorial ID :{$row[0]}  <br> ".
         "Title: {$row[1]} <br> ". "Author: {$row[2]} <br> ".
         "Submission Date : {$row[3]} <br> ". "--------------------------------<br>"; } mysql_free_result($retval);
   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Ao buscar dados, você pode escrever um código tão complexo quanto desejar, mas o procedimento permanecerá o mesmo mencionado acima.

Vimos o SQL SELECTcomando para buscar dados de uma tabela MySQL. Podemos usar uma cláusula condicional chamada deWHERE Clausepara filtrar os resultados. Usando esta cláusula WHERE, podemos especificar um critério de seleção para selecionar os registros necessários de uma tabela.

Sintaxe

O bloco de código a seguir possui uma sintaxe SQL genérica do comando SELECT com a cláusula WHERE para buscar dados da tabela MySQL -

SELECT field1, field2,...fieldN table_name1, table_name2...
[WHERE condition1 [AND [OR]] condition2.....

• Você pode usar uma ou mais tabelas separadas por uma vírgula para incluir várias condições usando uma cláusula WHERE, mas a cláusula WHERE é uma parte opcional do comando SELECT.

• Você pode especificar qualquer condição usando a cláusula WHERE.

• Você pode especificar mais de uma condição usando o AND ou o OR operadores.

• Uma cláusula WHERE pode ser usada junto com o comando DELETE ou UPDATE SQL também para especificar uma condição.

o WHERE cláusula funciona como um if conditionem qualquer linguagem de programação. Esta cláusula é usada para comparar o valor fornecido com o valor do campo disponível em uma tabela MySQL. Se o valor fornecido de fora for igual ao valor do campo disponível na tabela MySQL, ele retornará essa linha.

Aqui está a lista de operadores, que podem ser usados ​​com o WHERE cláusula.

Suponha que o campo A tenha 10 e o campo B tenha 20, então -

Operador	Descrição	Exemplo
=	Verifica se os valores dos dois operandos são iguais ou não, caso sim, a condição torna-se verdadeira.	(A = B) não é verdade.
! =	Verifica se os valores dos dois operandos são iguais ou não, se os valores não são iguais a condição se torna verdadeira.	(A! = B) é verdade.
>	Verifica se o valor do operando esquerdo é maior que o valor do operando direito, se sim, a condição se torna verdadeira.	(A> B) não é verdade.
<	Verifica se o valor do operando esquerdo é menor que o valor do operando direito, se sim a condição torna-se verdadeira.	(A <B) é verdade.
> =	Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se sim, a condição se torna verdadeira.	(A> = B) não é verdade.
<=	Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito, se sim, a condição se torna verdadeira.	(A <= B) é verdadeiro.

A cláusula WHERE é muito útil quando você deseja buscar as linhas selecionadas de uma tabela, especialmente quando você usa o MySQL Join. As junções são discutidas em outro capítulo.

É uma prática comum pesquisar registros usando o Primary Key para tornar a pesquisa mais rápida.

Se a condição fornecida não corresponder a nenhum registro na tabela, a consulta não retornará nenhuma linha.

Buscando dados no prompt de comando

Isso usará o comando SQL SELECT com a cláusula WHERE para buscar os dados selecionados da tabela MySQL - tutorials_tbl.

Exemplo

O exemplo a seguir retornará todos os registros do tutorials_tbl tabela para a qual o nome do autor é Sanjay.

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl WHERE tutorial_author = 'Sanjay';
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|      3      | JAVA Tutorial  |      Sanjay     |    2007-05-21   |      
+-------------+----------------+-----------------+-----------------+
1 rows in set (0.01 sec)

mysql>

A menos que execute um LIKEcomparação em uma string, a comparação não diferencia maiúsculas de minúsculas. Você pode tornar sua pesquisa sensível a maiúsculas e minúsculas usando oBINARY palavra-chave da seguinte forma -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl \
   WHERE BINARY tutorial_author = 'sanjay';
Empty set (0.02 sec)

mysql>

Buscando dados usando um script PHP

Você pode usar o mesmo comando SQL SELECT com WHERE CLAUSE na função PHP mysql_query(). Esta função é usada para executar o comando SQL e posteriormente outra função PHPmysql_fetch_array()pode ser usado para buscar todos os dados selecionados. Esta função retorna uma linha como uma matriz associativa, uma matriz numérica ou ambos. Esta função retorna FALSE se não houver mais linhas.

Exemplo

O exemplo a seguir retornará todos os registros do tutorials_tbl tabela para a qual o nome do autor é Sanjay -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);

   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT tutorial_id, tutorial_title, 
      tutorial_author, submission_date
      FROM tutorials_tbl
      WHERE tutorial_author = "Sanjay"';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Tutorial ID :{$row['tutorial_id']} <br> ". "Title: {$row['tutorial_title']} <br> ".
      "Author: {$row['tutorial_author']} <br> ". "Submission Date : {$row['submission_date']} <br> ".
      "--------------------------------<br>";
   } 

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Pode haver um requisito em que os dados existentes em uma tabela MySQL precisem ser modificados. Você pode fazer isso usando o SQLUPDATEcomando. Isso modificará qualquer valor de campo de qualquer tabela MySQL.

Sintaxe

O bloco de código a seguir tem uma sintaxe SQL genérica do comando UPDATE para modificar os dados na tabela MySQL -

UPDATE table_name SET field1 = new-value1, field2 = new-value2
[WHERE Clause]

• Você pode atualizar um ou mais campos completamente.
• Você pode especificar qualquer condição usando a cláusula WHERE.
• Você pode atualizar os valores em uma única tabela por vez.

A cláusula WHERE é muito útil quando você deseja atualizar as linhas selecionadas em uma tabela.

Atualização de dados do prompt de comando

Isso usará o comando SQL UPDATE com a cláusula WHERE para atualizar os dados selecionados na tabela MySQL tutorials_tbl.

Exemplo

O exemplo a seguir atualizará o tutorial_title campo para um registro com tutorial_id como 3.

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> UPDATE tutorials_tbl 
   -> SET tutorial_title = 'Learning JAVA' 
   -> WHERE tutorial_id = 3;
Query OK, 1 row affected (0.04 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql>

Atualizando dados usando um script PHP

Você pode usar o comando SQL UPDATE com ou sem WHERE CLAUSE na função PHP - mysql_query(). Esta função executará o comando SQL de uma forma semelhante que é executada no prompt mysql>.

Exemplo

O exemplo a seguir para atualizar o tutorial_title campo para um registro com tutorial_id como 3.

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'UPDATE tutorials_tbl
      SET tutorial_title="Learning JAVA"
      WHERE tutorial_id=3';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not update data: ' . mysql_error());
   }
   echo "Updated data successfully\n";
   mysql_close($conn);
?>

Se você deseja excluir um registro de qualquer tabela MySQL, você pode usar o comando SQL DELETE FROM. Você pode usar este comando no prompt mysql>, bem como em qualquer script como PHP.

Sintaxe

O bloco de código a seguir possui uma sintaxe SQL genérica do comando DELETE para excluir dados de uma tabela MySQL.

DELETE FROM table_name [WHERE Clause]

• Se a cláusula WHERE não for especificada, todos os registros serão excluídos da tabela MySQL fornecida.

• Você pode especificar qualquer condição usando a cláusula WHERE.

• Você pode excluir registros em uma única tabela por vez.

A cláusula WHERE é muito útil quando você deseja excluir linhas selecionadas em uma tabela.

Exclusão de dados do prompt de comando

Isso usará o comando SQL DELETE com a cláusula WHERE para excluir os dados selecionados na tabela MySQL - tutorials_tbl.

Exemplo

O exemplo a seguir excluirá um registro do tutorial_tbl cujo tutorial_id é 3.

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> DELETE FROM tutorials_tbl WHERE tutorial_id=3;
Query OK, 1 row affected (0.23 sec)

mysql>

Excluindo dados usando um script PHP

Você pode usar o comando SQL DELETE com ou sem WHERE CLAUSE na função PHP - mysql_query(). Esta função executará o comando SQL da mesma forma que é executada no prompt mysql>.

Exemplo

Tente o exemplo a seguir para excluir um registro do tutorial_tbl cujo tutorial_id é 3.

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'DELETE FROM tutorials_tbl WHERE tutorial_id = 3';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not delete data: ' . mysql_error());
   }
   echo "Deleted data successfully\n";
   mysql_close($conn);
?>

Vimos o SQL SELECTcomando para buscar dados da tabela MySQL. Também podemos usar uma cláusula condicional chamada deWHERE cláusula para selecionar os registros necessários.

Uma cláusula WHERE com o sinal 'igual a' (=) funciona bem onde queremos fazer uma correspondência exata. Como se "tutorial_author = 'Sanjay'". Mas pode haver um requisito em que queremos filtrar todos os resultados onde o nome do tutorial_author deve conter "jay". Isso pode ser tratado usandoSQL LIKE Clause junto com a cláusula WHERE.

Se a cláusula SQL LIKE for usada junto com o caractere%, ela funcionará como um metacaractere (*) como no UNIX, ao listar todos os arquivos ou diretórios no prompt de comando. Sem o caractere%, a cláusula LIKE é muito semelhante àequal to assinar junto com a cláusula WHERE.

Sintaxe

O bloco de código a seguir tem uma sintaxe SQL genérica do comando SELECT junto com a cláusula LIKE para buscar dados de uma tabela MySQL.

SELECT field1, field2,...fieldN table_name1, table_name2...
WHERE field1 LIKE condition1 [AND [OR]] filed2 = 'somevalue'

• Você pode especificar qualquer condição usando a cláusula WHERE.

• Você pode usar a cláusula LIKE junto com a cláusula WHERE.

• Você pode usar a cláusula LIKE no lugar do equals to placa.

• Quando LIKE é usado junto com o sinal%, ele funcionará como uma pesquisa de metacaracteres.

• Você pode especificar mais de uma condição usando AND ou OR operadores.

• Uma cláusula WHERE ... LIKE pode ser usada junto com o comando DELETE ou UPDATE SQL também para especificar uma condição.

Usando a cláusula LIKE no prompt de comando

Isso usará o comando SQL SELECT com a cláusula WHERE ... LIKE para buscar os dados selecionados da tabela MySQL - tutorials_tbl.

Exemplo

O exemplo a seguir retornará todos os registros do tutorials_tbl tabela para a qual o nome do autor termina com jay -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl 
   -> WHERE tutorial_author LIKE '%jay';
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|      3      |  JAVA Tutorial |     Sanjay      |    2007-05-21   |   
+-------------+----------------+-----------------+-----------------+
1 rows in set (0.01 sec)

mysql>

Usando a cláusula LIKE dentro do script PHP

Você pode usar uma sintaxe semelhante da cláusula WHERE ... LIKE na função PHP - mysql_query(). Esta função é usada para executar o comando SQL e posteriormente outra função PHP -mysql_fetch_array() pode ser usado para buscar todos os dados selecionados, se a cláusula WHERE ... LIKE for usada junto com o comando SELECT.

Mas se a cláusula WHERE ... LIKE estiver sendo usada com o comando DELETE ou UPDATE, nenhuma outra chamada de função PHP será necessária.

Exemplo

Experimente o exemplo a seguir para retornar todos os registros do tutorials_tbl tabela para a qual o nome do autor contém jay -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);

   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT tutorial_id, tutorial_title, 
      tutorial_author, submission_date
      FROM tutorials_tbl
      WHERE tutorial_author LIKE "%jay%"';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Tutorial ID :{$row['tutorial_id']} <br> ". "Title: {$row['tutorial_title']} <br> ".
         "Author: {$row['tutorial_author']} <br> ". "Submission Date : {$row['submission_date']} <br> ".
         "--------------------------------<br>";
   } 
   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Vimos o SQL SELECTcomando para buscar dados de uma tabela MySQL. Quando você seleciona linhas, o servidor MySQL está livre para retorná-las em qualquer ordem, a menos que você instrua de outra forma dizendo como classificar o resultado. Mas, você classifica um conjunto de resultados adicionando umORDER BY cláusula que nomeia a coluna ou colunas que você deseja classificar.

Sintaxe

O seguinte bloco de código é uma sintaxe SQL genérica do comando SELECT junto com a cláusula ORDER BY para classificar os dados de uma tabela MySQL.

SELECT field1, field2,...fieldN table_name1, table_name2...
ORDER BY field1, [field2...] [ASC [DESC]]

• Você pode classificar o resultado retornado em qualquer campo, se esse campo estiver sendo listado.

• Você pode classificar o resultado em mais de um campo.

• Você pode usar a palavra-chave ASC ou DESC para obter o resultado em ordem crescente ou decrescente. Por padrão, é a ordem crescente.

• Você pode usar a cláusula WHERE ... LIKE da maneira usual para colocar uma condição.

Usando a cláusula ORDER BY no Prompt de Comando

Isso usará o comando SQL SELECT com o ORDER BY cláusula para buscar dados da tabela MySQL - tutorials_tbl.

Exemplo

Experimente o exemplo a seguir, que retorna o resultado em ordem crescente.

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from tutorials_tbl ORDER BY tutorial_author ASC
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|      2      |  Learn MySQL   |     Abdul S     |    2007-05-24   |   
|      1      |   Learn PHP    |    John Poul    |    2007-05-24   |   
|      3      | JAVA Tutorial  |     Sanjay      |    2007-05-06   |   
+-------------+----------------+-----------------+-----------------+
3 rows in set (0.42 sec)

mysql>

Verifique todos os nomes de autor listados em ordem crescente.

Usando a cláusula ORDER BY dentro de um script PHP

Você pode usar uma sintaxe semelhante da cláusula ORDER BY na função PHP - mysql_query(). Esta função é usada para executar o comando SQL e posteriormente outra função PHPmysql_fetch_array() pode ser usado para buscar todos os dados selecionados.

Exemplo

Experimente o exemplo a seguir, que retorna o resultado em ordem decrescente dos autores do tutorial.

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT tutorial_id, tutorial_title, 
      tutorial_author, submission_date
      FROM tutorials_tbl
      ORDER BY  tutorial_author DESC';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Tutorial ID :{$row['tutorial_id']} <br> ". "Title: {$row['tutorial_title']} <br> ".
         "Author: {$row['tutorial_author']} <br> ". "Submission Date : {$row['submission_date']} <br> ".
         "--------------------------------<br>";
   } 
   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Nos capítulos anteriores, estávamos obtendo dados de uma tabela por vez. Isso é bom o suficiente para tomadas simples, mas na maioria dos usos do MySQL no mundo real, você frequentemente precisará obter dados de várias tabelas em uma única consulta.

Você pode usar várias tabelas em sua única consulta SQL. O ato de ingressar no MySQL se refere a quebrar duas ou mais tabelas em uma única tabela.

Você pode usar JOINS nas instruções SELECT, UPDATE e DELETE para juntar as tabelas do MySQL. Veremos também um exemplo de LEFT JOIN, que é diferente do simples MySQL JOIN.

Usando associações no prompt de comando

Suponha que temos duas tabelas tcount_tbl e tutorials_tbl, em TUTORIAIS. Agora dê uma olhada nos exemplos fornecidos abaixo -

Exemplo

Os exemplos a seguir -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * FROM tcount_tbl;
+-----------------+----------------+
| tutorial_author | tutorial_count |
+-----------------+----------------+
|      mahran     |       20       |     
|      mahnaz     |      NULL      |        
|       Jen       |      NULL      |          
|      Gill       |       20       |          
|    John Poul    |        1       |      
|     Sanjay      |        1       |        
+-----------------+----------------+
6 rows in set (0.01 sec)
mysql> SELECT * from tutorials_tbl;
+-------------+----------------+-----------------+-----------------+
| tutorial_id | tutorial_title | tutorial_author | submission_date |
+-------------+----------------+-----------------+-----------------+
|      1      |  Learn PHP     |     John Poul   |    2007-05-24   |   
|      2      |  Learn MySQL   |      Abdul S    |    2007-05-24   |   
|      3      | JAVA Tutorial  |      Sanjay     |    2007-05-06   |   
+-------------+----------------+-----------------+-----------------+
3 rows in set (0.00 sec)
mysql>

Agora podemos escrever uma consulta SQL para unir essas duas tabelas. Esta consulta irá selecionar todos os autores da tabelatutorials_tbl e pegará o número correspondente de tutoriais do tcount_tbl.

mysql> SELECT a.tutorial_id, a.tutorial_author, b.tutorial_count
   -> FROM tutorials_tbl a, tcount_tbl b
   -> WHERE a.tutorial_author = b.tutorial_author;
+-------------+-----------------+----------------+
| tutorial_id | tutorial_author | tutorial_count |
+-------------+-----------------+----------------+
|      1      |    John Poul    |        1       |
|      3      |     Sanjay      |        1       |
+-------------+-----------------+----------------+
2 rows in set (0.01 sec)
mysql>

Usando Joins em um Script PHP

Você pode usar qualquer uma das consultas SQL mencionadas acima no script PHP. Você só precisa passar a consulta SQL para a função PHPmysql_query() e você buscará os resultados da maneira usual.

Exemplo

O exemplo a seguir -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT a.tutorial_id, a.tutorial_author, b.tutorial_count
      FROM tutorials_tbl a, tcount_tbl b
      WHERE a.tutorial_author = b.tutorial_author';

   mysql_select_db('TUTORIALS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Author:{$row['tutorial_author']} <br> ". "Count: {$row['tutorial_count']} <br> ".
         "Tutorial ID: {$row['tutorial_id']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

MySQL LEFT JOIN

Uma junção à esquerda do MySQL é diferente de uma junção simples. Um MySQL LEFT JOIN dá alguma consideração extra à tabela que está à esquerda.

Se eu fizer um LEFT JOIN, Obtenho todos os registros que correspondem da mesma maneira e ALÉM DISSO obtenho um registro extra para cada registro não correspondido na tabela à esquerda da junção: garantindo assim (no meu exemplo) que cada AUTOR receba uma menção.

Exemplo

Experimente o seguinte exemplo para entender o LEFT JOIN.

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT a.tutorial_id, a.tutorial_author, b.tutorial_count
   -> FROM tutorials_tbl a LEFT JOIN tcount_tbl b
   -> ON a.tutorial_author = b.tutorial_author;
+-------------+-----------------+----------------+
| tutorial_id | tutorial_author | tutorial_count |
+-------------+-----------------+----------------+
|      1      |    John Poul    |       1        |
|      2      |     Abdul S     |      NULL      |
|      3      |     Sanjay      |       1        |
+-------------+-----------------+----------------+
3 rows in set (0.02 sec)

Você precisaria praticar mais para se familiarizar com JOINS. Este é um conceito um pouco complexo no MySQL / SQL e ficará mais claro ao fazer exemplos reais.

Vimos o SQL SELECT comando junto com o WHERE cláusula para buscar dados de uma tabela MySQL, mas quando tentamos dar uma condição, que compara o campo ou o valor da coluna com NULL, ele não funciona corretamente.

Para lidar com tal situação, o MySQL fornece três operadores -

• IS NULL - Este operador retorna verdadeiro, se o valor da coluna for NULL.

• IS NOT NULL - Este operador retorna verdadeiro, se o valor da coluna não for NULL.

• <=> - Este operador compara valores, que (ao contrário do operador =) é verdadeiro mesmo para dois valores NULL.

As condições envolvendo NULL são especiais. Você não pode usar =NULL ou! = NULLpara procurar valores NULL nas colunas. Essas comparações sempre falham porque é impossível dizer se são verdadeiras ou não. Às vezes, mesmo NULL = NULL falha.

Para procurar colunas que são ou não NULL, use IS NULL ou IS NOT NULL.

Usando valores NULL no prompt de comando

Suponha que haja uma mesa chamada tcount_tbl no banco de dados TUTORIALS e contém duas colunas, a saber tutorial_author e tutorial_count, onde um tutorial_count NULL indica que o valor é desconhecido.

Exemplo

Experimente os seguintes exemplos -

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> create table tcount_tbl
   -> (
   -> tutorial_author varchar(40) NOT NULL,
   -> tutorial_count  INT
   -> );
Query OK, 0 rows affected (0.05 sec)

mysql> INSERT INTO tcount_tbl
   -> (tutorial_author, tutorial_count) values ('mahran', 20);

mysql> INSERT INTO tcount_tbl
   -> (tutorial_author, tutorial_count) values ('mahnaz', NULL);

mysql> INSERT INTO tcount_tbl
   -> (tutorial_author, tutorial_count) values ('Jen', NULL);

mysql> INSERT INTO tcount_tbl
   -> (tutorial_author, tutorial_count) values ('Gill', 20);

mysql> SELECT * from tcount_tbl;
+-----------------+----------------+
| tutorial_author | tutorial_count |
+-----------------+----------------+
|     mahran      |       20       |
|     mahnaz      |      NULL      |
|      Jen        |      NULL      |
|     Gill        |       20       |
+-----------------+----------------+
4 rows in set (0.00 sec)

mysql>

Você pode ver que = e != não trabalhe com valores NULL da seguinte maneira -

mysql> SELECT * FROM tcount_tbl WHERE tutorial_count = NULL;
Empty set (0.00 sec)

mysql> SELECT * FROM tcount_tbl WHERE tutorial_count != NULL;
Empty set (0.01 sec)

Para localizar os registros em que a coluna tutorial_count é ou não NULL, as consultas devem ser escritas conforme mostrado no programa a seguir.

mysql> SELECT * FROM tcount_tbl 
   -> WHERE tutorial_count IS NULL;
+-----------------+----------------+
| tutorial_author | tutorial_count |
+-----------------+----------------+
|     mahnaz      |      NULL      |
|      Jen        |      NULL      |
+-----------------+----------------+
2 rows in set (0.00 sec)
mysql> SELECT * from tcount_tbl 
   -> WHERE tutorial_count IS NOT NULL;
+-----------------+----------------+
| tutorial_author | tutorial_count |
+-----------------+----------------+
|     mahran      |       20       |
|     Gill        |       20       |
+-----------------+----------------+
2 rows in set (0.00 sec)

Manipulação de valores NULL em um script PHP

Você pode usar o if...else condição para preparar uma consulta com base no valor NULL.

Exemplo

O exemplo a seguir pega o tutorial_count de fora e depois compara com o valor disponível na tabela.

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   if( isset($tutorial_count )) { $sql = 'SELECT tutorial_author, tutorial_count
         FROM  tcount_tbl
         WHERE tutorial_count = $tutorial_count'; } else { $sql = 'SELECT tutorial_author, tutorial_count
         FROM  tcount_tbl
         WHERE tutorial_count IS $tutorial_count'; } mysql_select_db('TUTORIALS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Author:{$row['tutorial_author']}  <br> ".
         "Count: {$row['tutorial_count']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Você viu o padrão do MySQL combinando com LIKE ...%. MySQL suporta outro tipo de operação de correspondência de padrões com base nas expressões regulares eREGEXPoperador. Se você conhece PHP ou PERL, é muito simples de entender, porque essa correspondência é a mesma que os scripts de expressões regulares.

A seguir está a tabela de padrões, que pode ser usada junto com o REGEXP operador.

padronizar	O que o padrão corresponde
^	Começo da corda
$	Fim da corda
.	Qualquer personagem
[...]	Qualquer caractere listado entre colchetes
[^ ...]	Qualquer caractere não listado entre colchetes
p1 | p2 | p3	Alternação; corresponde a qualquer um dos padrões p1, p2 ou p3
*	Zero ou mais instâncias do elemento anterior
+	Uma ou mais instâncias do elemento anterior
{n}	n instâncias do elemento anterior
{m, n}	m a n instâncias do elemento anterior

Exemplos

Agora, com base na tabela acima, você pode dispositivos vários tipos de consultas SQL para atender aos seus requisitos. Aqui, estou listando alguns para sua compreensão.

Considere que temos uma mesa chamada person_tbl e está tendo um campo chamado name -

Consulta para encontrar todos os nomes que começam com 'st' -

mysql> SELECT name FROM person_tbl WHERE name REGEXP '^st';

Consulte para encontrar todos os nomes que terminam com 'ok' -

mysql> SELECT name FROM person_tbl WHERE name REGEXP 'ok$';

Consulte para encontrar todos os nomes, que contêm 'mar' -

mysql> SELECT name FROM person_tbl WHERE name REGEXP 'mar';

Consulte para encontrar todos os nomes que começam com uma vogal e terminam com 'ok' -

mysql> SELECT FirstName FROM intque.person_tbl WHERE FirstName REGEXP '^[aeiou].*ok$';

Uma transação é um grupo sequencial de operações de manipulação de banco de dados, que é executado como se fosse uma única unidade de trabalho. Em outras palavras, uma transação nunca será concluída a menos que cada operação individual dentro do grupo seja bem-sucedida. Se qualquer operação dentro da transação falhar, toda a transação falhará.

Praticamente, você agrupará muitas consultas SQL em um grupo e executará todas elas juntas como parte de uma transação.

Propriedades das transações

As transações têm as quatro propriedades padrão a seguir, geralmente referidas pela sigla ACID -

• Atomicity- Isso garante que todas as operações dentro da unidade de trabalho sejam concluídas com êxito; caso contrário, a transação é abortada no ponto de falha e as operações anteriores são revertidas para seu estado anterior.

• Consistency - Isso garante que o banco de dados mude de estado corretamente após uma transação confirmada com sucesso.

• Isolation - Isso permite que as transações operem de forma independente e transparente entre si.

• Durability - Isso garante que o resultado ou efeito de uma transação confirmada persista em caso de falha do sistema.

No MySQL, as transações começam com a instrução BEGIN WORK e terminar com um COMMIT ou um ROLLBACKdeclaração. Os comandos SQL entre as instruções inicial e final formam a maior parte da transação.

COMMIT e ROLLBACK

Essas duas palavras-chave Commit e Rollback são usados ​​principalmente para transações MySQL.

• Quando uma transação bem-sucedida é concluída, o comando COMMIT deve ser emitido para que as alterações em todas as tabelas envolvidas tenham efeito.

• Se ocorrer uma falha, um comando ROLLBACK deve ser emitido para retornar todas as tabelas referenciadas na transação ao seu estado anterior.

Você pode controlar o comportamento de uma transação definindo a variável de sessão chamada AUTOCOMMIT. Se AUTOCOMMIT for definido como 1 (o padrão), cada instrução SQL (dentro de uma transação ou não) é considerada uma transação completa e confirmada por padrão quando termina.

Quando AUTOCOMMIT é definido como 0, emitindo o SET AUTOCOMMIT = 0 comando, a série subsequente de instruções age como uma transação e nenhuma atividade é confirmada até que uma instrução COMMIT explícita seja emitida.

Você pode executar esses comandos SQL em PHP usando o mysql_query() função.

Um exemplo genérico de transação

Essa sequência de eventos é independente da linguagem de programação usada. O caminho lógico pode ser criado em qualquer idioma que você usar para criar seu aplicativo.

Você pode executar esses comandos SQL em PHP usando o mysql_query() função.

• Comece a transação emitindo o comando SQL BEGIN WORK.

• Emita um ou mais comandos SQL como SELECT, INSERT, UPDATE ou DELETE.

• Verifique se não há erro e tudo está de acordo com sua exigência.

• Se houver algum erro, emita um comando ROLLBACK, caso contrário, emita um comando COMMIT.

Tipos de tabela segura para transações no MySQL

Você não pode usar transações diretamente, mas para certas exceções você pode. No entanto, eles não são seguros e garantidos. Se você planeja usar transações em sua programação MySQL, precisa criar suas tabelas de uma maneira especial. Existem muitos tipos de tabelas que suportam transações, mas o mais popular éInnoDB.

O suporte para tabelas InnoDB requer um parâmetro de compilação específico ao compilar o MySQL a partir da fonte. Se sua versão do MySQL não tiver suporte para InnoDB, peça ao seu provedor de serviços de Internet para construir uma versão do MySQL com suporte para tipos de tabela InnoDB ou baixe e instaleMySQL-Max Binary Distribution para Windows ou Linux / UNIX e trabalhar com o tipo de tabela em um ambiente de desenvolvimento.

Se a sua instalação do MySQL suportar tabelas InnoDB, basta adicionar um TYPE = InnoDB definição para a instrução de criação da tabela.

Por exemplo, o código a seguir cria uma tabela InnoDB chamada tcount_tbl -

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> create table tcount_tbl
   -> (
   -> tutorial_author varchar(40) NOT NULL,
   -> tutorial_count  INT
   -> ) TYPE = InnoDB;
Query OK, 0 rows affected (0.05 sec)

Para obter mais detalhes sobre InnoDB, você pode clicar no seguinte link - InnoDB

Você pode usar outros tipos de tabela como GEMINI ou BDB, mas depende da sua instalação, se ele suporta esses dois tipos de mesa ou não.

O MySQL ALTER O comando é muito útil quando você deseja alterar o nome de sua tabela, qualquer campo da tabela ou se deseja adicionar ou excluir uma coluna existente em uma tabela.

Vamos começar com a criação de uma mesa chamada testalter_tbl.

root@host# mysql -u root -p password;
Enter password:*******

mysql> use TUTORIALS;
Database changed

mysql> create table testalter_tbl
   -> (
   -> i INT,
   -> c CHAR(1)
   -> );
Query OK, 0 rows affected (0.05 sec)
mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field |  Type   | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
|   i   | int(11) | YES  |     |   NULL  |       |
|   c   | char(1) | YES  |     |   NULL  |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Descartando, Adicionando ou Reposicionando uma Coluna

Se você quiser remover uma coluna i existente da tabela MySQL acima, então você usará o DROP cláusula junto com a ALTER comando como mostrado abaixo -

mysql> ALTER TABLE testalter_tbl  DROP i;

UMA DROP A cláusula não funcionará se a coluna for a única que restou na tabela.

Para adicionar uma coluna, use ADD e especifique a definição da coluna. A seguinte declaração restaura oi coluna para o testalter_tbl -

mysql> ALTER TABLE testalter_tbl ADD i INT;

Depois de emitir esta declaração, testalter conterá as mesmas duas colunas que tinha quando você criou a tabela pela primeira vez, mas não terá a mesma estrutura. Isso ocorre porque há novas colunas adicionadas ao final da tabela por padrão. Então, emborai originalmente era a primeira coluna em mytbl, agora é a última.

mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field |  Type   | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
|   c   | char(1) | YES  |     |   NULL  |       |
|   i   | int(11) | YES  |     |   NULL  |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Para indicar que você deseja uma coluna em uma posição específica dentro da tabela, use FIRST para torná-la a primeira coluna ou AFTER col_name para indicar que a nova coluna deve ser colocada após o nome_coluna.

Tente o seguinte ALTER TABLE declarações, usando SHOW COLUMNS depois de cada um para ver o efeito que cada um tem -

ALTER TABLE testalter_tbl DROP i;
ALTER TABLE testalter_tbl ADD i INT FIRST;
ALTER TABLE testalter_tbl DROP i;
ALTER TABLE testalter_tbl ADD i INT AFTER c;

Os especificadores FIRST e AFTER funcionam apenas com a cláusula ADD. Isso significa que se você deseja reposicionar uma coluna existente dentro de uma tabela, você deve primeiroDROP isso e então ADD na nova posição.

Alterando (mudando) uma definição de coluna ou um nome

Para alterar a definição de uma coluna, use MODIFY ou CHANGE cláusula junto com o comando ALTER.

Por exemplo, para alterar a coluna c de CHAR (1) a CHAR (10), você pode usar o seguinte comando -

mysql> ALTER TABLE testalter_tbl MODIFY c CHAR(10);

Com CHANGE, a sintaxe é um pouco diferente. Após a palavra-chave CHANGE, você nomeia a coluna que deseja alterar e, a seguir, especifica a nova definição, que inclui o novo nome.

Experimente o seguinte exemplo -

mysql> ALTER TABLE testalter_tbl CHANGE i j BIGINT;

Se você agora usa CHANGE para converter j de BIGINT de volta a INT sem alterar o nome da coluna, a instrução será como mostrado abaixo -

mysql> ALTER TABLE testalter_tbl CHANGE j j INT;

The Effect of ALTER TABLE on Null and Default Value Attributes- Ao MODIFICAR ou ALTERAR uma coluna, você também pode especificar se a coluna pode ou não conter valores NULL e qual é seu valor padrão. Na verdade, se você não fizer isso, o MySQL atribuirá valores automaticamente para esses atributos.

O seguinte bloco de código é um exemplo, onde o NOT NULL coluna terá o valor 100 por padrão.

mysql> ALTER TABLE testalter_tbl 
   -> MODIFY j BIGINT NOT NULL DEFAULT 100;

Se você não usar o comando acima, o MySQL preencherá os valores NULL em todas as colunas.

Alterando (mudando) o valor padrão de uma coluna

Você pode alterar um valor padrão para qualquer coluna usando o ALTER comando.

Experimente o seguinte exemplo.

mysql> ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field |  Type   | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
|   c   | char(1) | YES  |     |   NULL  |       |
|   i   | int(11) | YES  |     |   1000  |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Você pode remover a restrição padrão de qualquer coluna usando a cláusula DROP junto com o ALTER comando.

mysql> ALTER TABLE testalter_tbl ALTER i DROP DEFAULT;
mysql> SHOW COLUMNS FROM testalter_tbl;
+-------+---------+------+-----+---------+-------+
| Field |  Type   | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
|   c   | char(1) | YES  |     |   NULL  |       |
|   i   | int(11) | YES  |     |   NULL  |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Alterando (mudando) um tipo de tabela

Você pode usar um tipo de tabela usando o TYPEcláusula junto com o comando ALTER. Experimente o seguinte exemplo para mudar otestalter_tbl para MYISAM tipo de mesa.

Para descobrir o tipo atual de uma tabela, use o SHOW TABLE STATUS declaração.

mysql> ALTER TABLE testalter_tbl TYPE = MYISAM;
mysql>  SHOW TABLE STATUS LIKE 'testalter_tbl'\G
*************************** 1. row ****************
           Name: testalter_tbl
           Type: MyISAM
     Row_format: Fixed
           Rows: 0
 Avg_row_length: 0
    Data_length: 0
Max_data_length: 25769803775
   Index_length: 1024
      Data_free: 0
 Auto_increment: NULL
    Create_time: 2007-06-03 08:04:36
    Update_time: 2007-06-03 08:04:36
     Check_time: NULL
 Create_options:
        Comment:
1 row in set (0.00 sec)

Renomeando (Alterando) uma Tabela

Para renomear uma tabela, use o RENAME opção do ALTER TABLE declaração.

Experimente o seguinte exemplo para renomear testalter_tbl para alter_tbl.

mysql> ALTER TABLE testalter_tbl RENAME TO alter_tbl;

Você pode usar o comando ALTER para criar e soltar o comando INDEX em um arquivo MySQL. Discutiremos em detalhes sobre esse comando no próximo capítulo.

Um índice de banco de dados é uma estrutura de dados que melhora a velocidade das operações em uma tabela. Os índices podem ser criados usando uma ou mais colunas, fornecendo a base para pesquisas aleatórias rápidas e ordenação eficiente de acesso aos registros.

Ao criar o índice, deve-se levar em consideração que todas as colunas serão utilizadas para fazer consultas SQL e criar um ou mais índices nessas colunas.

Praticamente, os índices também são um tipo de tabela, que mantém a chave primária ou campo de índice e um ponteiro para cada registro na tabela real.

Os usuários não podem ver os índices, eles são usados ​​apenas para agilizar as consultas e serão usados ​​pelo Database Search Engine para localizar registros muito rapidamente.

As instruções INSERT e UPDATE demoram mais em tabelas com índices, enquanto as instruções SELECT tornam-se rápidas nessas tabelas. O motivo é que, ao fazer a inserção ou atualização, um banco de dados também precisa inserir ou atualizar os valores do índice.

Índice Simples e Único

Você pode criar um índice exclusivo em uma tabela. Um índice exclusivo significa que duas linhas não podem ter o mesmo valor de índice. Aqui está a sintaxe para criar um índice em uma tabela.

CREATE UNIQUE INDEX index_name ON table_name ( column1, column2,...);

Você pode usar uma ou mais colunas para criar um índice.

Por exemplo, podemos criar um índice em tutorials_tbl usando tutorial_author.

CREATE UNIQUE INDEX AUTHOR_INDEX ON tutorials_tbl (tutorial_author)

Você pode criar um índice simples em uma tabela. Apenas omita oUNIQUEpalavra-chave da consulta para criar um índice simples. Um índice simples permite valores duplicados em uma tabela.

Se desejar indexar os valores em uma coluna em ordem decrescente, você pode adicionar a palavra reservada DESC após o nome da coluna.

mysql> CREATE UNIQUE INDEX AUTHOR_INDEX ON tutorials_tbl (tutorial_author DESC)

Comando ALTER para adicionar e eliminar INDEX

Existem quatro tipos de instruções para adicionar índices a uma tabela -

• ALTER TABLE tbl_name ADD PRIMARY KEY (column_list) - Esta declaração adiciona um PRIMARY KEY, o que significa que os valores indexados devem ser exclusivos e não podem ser NULL.

• ALTER TABLE tbl_name ADD UNIQUE index_name (column_list) - Esta instrução cria um índice para o qual os valores devem ser exclusivos (exceto para os valores NULL, que podem aparecer várias vezes).

• ALTER TABLE tbl_name ADD INDEX index_name (column_list) - Isso adiciona um índice comum no qual qualquer valor pode aparecer mais de uma vez.

• ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list) - Isso cria um índice FULLTEXT especial que é usado para fins de pesquisa de texto.

O bloco de código a seguir é um exemplo para adicionar índice em uma tabela existente.

mysql> ALTER TABLE testalter_tbl ADD INDEX (c);

Você pode eliminar qualquer INDEX usando o DROP cláusula junto com o comando ALTER.

Experimente o seguinte exemplo para eliminar o índice criado acima.

mysql> ALTER TABLE testalter_tbl DROP INDEX (c);

Você pode eliminar qualquer INDEX usando a cláusula DROP junto com o comando ALTER.

Comando ALTER para adicionar e soltar a CHAVE PRIMÁRIA

Você também pode adicionar uma chave primária da mesma maneira. Mas certifique-se de que a chave primária funcione em colunas, que NÃO são NULL.

O bloco de código a seguir é um exemplo para adicionar a chave primária em uma tabela existente. Isso tornará uma coluna NOT NULL primeiro e depois a adicionará como uma chave primária.

mysql> ALTER TABLE testalter_tbl MODIFY i INT NOT NULL;
mysql> ALTER TABLE testalter_tbl ADD PRIMARY KEY (i);

Você pode usar o comando ALTER para descartar uma chave primária da seguinte maneira -

mysql> ALTER TABLE testalter_tbl DROP PRIMARY KEY;

Para eliminar um índice que não seja uma PRIMARY KEY, você deve especificar o nome do índice.

Exibindo informações INDEX

Você pode usar o SHOW INDEXcomando para listar todos os índices associados a uma tabela. A saída de formato vertical (especificada por \ G) geralmente é útil com esta declaração, para evitar um contorno de linha longa -

Experimente o seguinte exemplo -

mysql> SHOW INDEX FROM table_name\G
........

As tabelas temporárias podem ser muito úteis em alguns casos para manter dados temporários. A coisa mais importante que deve ser conhecida sobre as tabelas temporárias é que elas serão excluídas quando a sessão atual do cliente terminar.

O que são tabelas temporárias?

Tabelas temporárias foram adicionadas no MySQL versão 3.23. Se você usa uma versão anterior do MySQL que 3.23, você não pode usar as tabelas temporárias, mas você pode usarHeap Tables.

Conforme declarado anteriormente, as tabelas temporárias durarão apenas enquanto a sessão estiver ativa. Se você executar o código em um script PHP, a tabela temporária será destruída automaticamente quando a execução do script terminar. Se você estiver conectado ao servidor de banco de dados MySQL por meio do programa cliente MySQL, a tabela temporária existirá até que você feche o cliente ou destrua manualmente a tabela.

Exemplo

O programa a seguir é um exemplo que mostra o uso da tabela temporária. O mesmo código pode ser usado em scripts PHP usando omysql_query() função.

mysql> CREATE TEMPORARY TABLE SalesSummary (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SalesSummary
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SalesSummary;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
|   cucumber   |   100.25    |     90.00      |         2        |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)

Quando você emite um SHOW TABLEScomando, então sua tabela temporária não seria listada na lista. Agora, se você sair da sessão do MySQL e, em seguida, emitirá umSELECTcomando, então você não encontrará dados disponíveis no banco de dados. Mesmo sua mesa temporária não existirá.

Descartando tabelas temporárias

Por padrão, todas as tabelas temporárias são excluídas pelo MySQL quando sua conexão com o banco de dados é encerrada. Ainda assim, se você quiser excluí-los no meio, faça isso emitindo oDROP TABLE comando.

O programa a seguir é um exemplo de eliminação de uma mesa temporária -

mysql> CREATE TEMPORARY TABLE SalesSummary (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SalesSummary
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SalesSummary;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
|   cucumber   |   100.25    |     90.00      |         2        |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
mysql> DROP TABLE SalesSummary;
mysql>  SELECT * FROM SalesSummary;
ERROR 1146: Table 'TUTORIALS.SalesSummary' doesn't exist

Pode haver uma situação em que você precise de uma cópia exata de uma tabela e CREATE TABLE ... SELECT não atende aos seus objetivos porque a cópia deve incluir os mesmos índices, valores padrão e assim por diante.

Você pode lidar com essa situação seguindo as etapas abaixo -

• Use SHOW CREATE TABLE para obter uma instrução CREATE TABLE que especifica a estrutura da tabela de origem, índices e tudo.

• Modifique a instrução para alterar o nome da tabela para aquele da tabela clone e execute a instrução. Dessa forma, você terá a tabela de clones exata.

• Opcionalmente, se você também precisar que o conteúdo da tabela seja copiado, emita uma instrução INSERT INTO ... SELECT também.

Exemplo

Experimente o seguinte exemplo para criar uma tabela clone para tutorials_tbl.

Step 1 - Obtenha a estrutura completa sobre a mesa.

mysql> SHOW CREATE TABLE tutorials_tbl \G;
*************************** 1. row ***************************
      Table: tutorials_tbl
Create Table: CREATE TABLE `tutorials_tbl` (
   `tutorial_id` int(11) NOT NULL auto_increment,
   `tutorial_title` varchar(100) NOT NULL default '',
   `tutorial_author` varchar(40) NOT NULL default '',
   `submission_date` date default NULL,
   PRIMARY KEY  (`tutorial_id`),
   UNIQUE KEY `AUTHOR_INDEX` (`tutorial_author`)
) TYPE = MyISAM
1 row in set (0.00 sec)

ERROR:
No query specified

Step 2 - Renomeie esta tabela e crie outra tabela.

mysql> CREATE TABLE clone_tbl (
   -> tutorial_id int(11) NOT NULL auto_increment,
   -> tutorial_title varchar(100) NOT NULL default '',
   -> tutorial_author varchar(40) NOT NULL default '',
   -> submission_date date default NULL,
   -> PRIMARY KEY  (tutorial_id),
   -> UNIQUE KEY AUTHOR_INDEX (tutorial_author)
-> ) TYPE = MyISAM;
Query OK, 0 rows affected (1.80 sec)

Step 3- Após executar a etapa 2, você criará uma tabela clone em seu banco de dados. Se você deseja copiar os dados da tabela antiga, pode fazê-lo usando a instrução INSERT INTO ... SELECT.

mysql> INSERT INTO clone_tbl (tutorial_id,
   -> tutorial_title,
   -> tutorial_author,
   -> submission_date)
   
   -> SELECT tutorial_id,tutorial_title,
   -> tutorial_author,submission_date
   -> FROM tutorials_tbl;
Query OK, 3 rows affected (0.07 sec)
Records: 3  Duplicates: 0  Warnings: 0

Por fim, você terá uma tabela de clones exata que deseja.

Obtenção e uso de metadados MySQL

Existem três tipos de informações que você gostaria de obter do MySQL.

• Information about the result of queries - Isso inclui o número de registros afetados por qualquer instrução SELECT, UPDATE ou DELETE.

• Information about the tables and databases - Inclui informações relativas à estrutura das tabelas e dos bancos de dados.

• Information about the MySQL server - Isso inclui o status do servidor de banco de dados, número da versão, etc.

É muito fácil obter todas essas informações no prompt do MySQL, mas ao usar APIs PERL ou PHP, precisamos chamar várias APIs explicitamente para obter todas essas informações.

Obtenção do número de linhas afetadas por uma consulta

Vamos agora ver como obter essas informações.

PERL Exemplo

Em scripts DBI, a contagem de linhas afetadas é retornada pelo do( ) ou pelo execute( ) comando, dependendo de como você executa a consulta.

# Method 1
# execute $query using do( )
my $count = $dbh->do ($query); # report 0 rows if an error occurred printf "%d rows were affected\n", (defined ($count) ? $count : 0); # Method 2 # execute query using prepare( ) plus execute( ) my $sth = $dbh->prepare ($query);
my $count = $sth->execute ( );
printf "%d rows were affected\n", (defined ($count) ? $count : 0);

Exemplo de PHP

Em PHP, invoque o mysql_affected_rows( ) função para descobrir quantas linhas uma consulta mudou.

$result_id = mysql_query ($query, $conn_id); # report 0 rows if the query failed $count = ($result_id ? mysql_affected_rows ($conn_id) : 0);
print ("$count rows were affected\n");

Listando tabelas e bancos de dados

É muito fácil listar todos os bancos de dados e as tabelas disponíveis com um servidor de banco de dados. Seu resultado pode sernull se você não tiver os privilégios suficientes.

Além do método que é mostrado no seguinte bloco de código, você pode usar SHOW TABLES ou SHOW DATABASES consultas para obter a lista de tabelas ou bancos de dados em PHP ou em PERL.

PERL Exemplo

# Get all the tables available in current database.
my @tables = $dbh->tables ( );

foreach $table (@tables ){ print "Table Name $table\n";
}

Exemplo de PHP

<?php
   $con = mysql_connect("localhost", "userid", "password"); if (!$con) {
      die('Could not connect: ' . mysql_error());
   }
   $db_list = mysql_list_dbs($con);

   while ($db = mysql_fetch_object($db_list)) {
      echo $db->Database . "<br />"; } mysql_close($con);
?>

Obtendo Metadados do Servidor

Existem alguns comandos importantes no MySQL que podem ser executados no prompt do MySQL ou usando qualquer script como PHP para obter várias informações importantes sobre o servidor de banco de dados.

Sr. Não.	Comando e Descrição
1	SELECT VERSION( ) String da versão do servidor
2	SELECT DATABASE( ) Nome do banco de dados atual (vazio se nenhum)
3	SELECT USER( ) Nome de usuário atual
4	SHOW STATUS Indicadores de status do servidor
5	SHOW VARIABLES Variáveis ​​de configuração do servidor

Uma sequência é um conjunto de inteiros 1, 2, 3, ... que são gerados em ordem em uma demanda específica. As sequências são freqüentemente usadas nos bancos de dados porque muitos aplicativos exigem que cada linha de uma tabela contenha um valor exclusivo e as sequências fornecem uma maneira fácil de gerá-los.

Este capítulo descreve como usar sequências no MySQL.

Usando a coluna AUTO_INCREMENT

A maneira mais simples no MySQL de usar Sequências é definir uma coluna como AUTO_INCREMENT e deixar o restante para o MySQL cuidar.

Exemplo

Experimente o seguinte exemplo. Isso criará a tabela e, em seguida, inserirá algumas linhas nesta tabela onde não é necessário fornecer o ID do registro porque é incrementado automaticamente pelo MySQL.

mysql> CREATE TABLE insect
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO insect (id,name,date,origin) VALUES
   -> (NULL,'housefly','2001-09-10','kitchen'),
   -> (NULL,'millipede','2001-09-10','driveway'),
   -> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM insect ORDER BY id;
+----+-------------+------------+------------+
| id |    name     |    date    |   origin   |
+----+-------------+------------+------------+
|  1 |  housefly   | 2001-09-10 |   kitchen  |
|  2 |  millipede  | 2001-09-10 |  driveway  |
|  3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

Obtenha os valores AUTO_INCREMENT

o LAST_INSERT_ID( )é uma função SQL, portanto, você pode usá-la em qualquer cliente que saiba como emitir instruções SQL. Caso contrário, os scripts PERL e PHP fornecem funções exclusivas para recuperar o valor incrementado automaticamente do último registro.

PERL Exemplo

Use o mysql_insertid atributo para obter o AUTO_INCREMENTvalor gerado por uma consulta. Este atributo é acessado por meio de um identificador de banco de dados ou um identificador de instrução, dependendo de como você emite a consulta.

O exemplo a seguir faz referência a ele por meio do identificador do banco de dados.

$dbh->do ("INSERT INTO insect (name,date,origin) VALUES('moth','2001-09-14','windowsill')"); my $seq = $dbh->{mysql_insertid};

Exemplo de PHP

Depois de emitir uma consulta que gere um valor AUTO_INCREMENT, recupere o valor chamando o mysql_insert_id( ) comando.

mysql_query ("INSERT INTO insect (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);

Renumerando uma sequência existente

Pode haver um caso em que você excluiu muitos registros de uma tabela e deseja sequenciar novamente todos os registros. Isso pode ser feito usando um truque simples, mas você deve ter muito cuidado ao fazer isso se sua tabela estiver tendo associações com a outra.

Se você determinar que o novo sequenciamento de uma coluna AUTO_INCREMENT é inevitável, a maneira de fazer isso é remover a coluna da tabela e adicioná-la novamente.

O exemplo a seguir mostra como renumerar o id values na tabela usando esta técnica.

mysql> ALTER TABLE insect DROP id;
mysql> ALTER TABLE insect
   -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
   -> ADD PRIMARY KEY (id);

Iniciando uma sequência em um valor particular

Por padrão, o MySQL iniciará a sequência de 1, mas você pode especificar qualquer outro número também no momento da criação da tabela.

O programa a seguir é um exemplo que mostra como o MySQL iniciará a sequência de 100.

mysql> CREATE TABLE insect
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);

Como alternativa, você pode criar a tabela e, em seguida, definir o valor da sequência inicial com o ALTER TABLE comando.

mysql> ALTER TABLE t AUTO_INCREMENT = 100;

Geralmente, as tabelas ou conjuntos de resultados às vezes contêm registros duplicados. Na maioria das vezes, é permitido, mas às vezes é necessário para impedir a duplicação de registros. É necessário identificar registros duplicados e removê-los da tabela. Este capítulo descreverá como evitar a ocorrência de registros duplicados em uma tabela e como remover os registros duplicados já existentes.

Evitando que ocorram duplicatas em uma tabela

Você pode usar um PRIMARY KEY ou um UNIQUE Índice em uma tabela com os campos apropriados para impedir registros duplicados.

Vejamos um exemplo - a tabela a seguir não contém esse índice ou chave primária, portanto, permitiria registros duplicados para first_name e last_name.

CREATE TABLE person_tbl (
   first_name CHAR(20),
   last_name CHAR(20),
   sex CHAR(10)
);

Para evitar que vários registros com os mesmos valores de nome e sobrenome sejam criados nesta tabela, adicione um PRIMARY KEYà sua definição. Quando você faz isso, também é necessário declarar as colunas indexadas comoNOT NULL, porque um PRIMARY KEY não permite NULL valores -

CREATE TABLE person_tbl (
   first_name CHAR(20) NOT NULL,
   last_name CHAR(20) NOT NULL,
   sex CHAR(10),
   PRIMARY KEY (last_name, first_name)
);

A presença de um índice exclusivo em uma tabela normalmente causa a ocorrência de um erro se você inserir um registro na tabela que duplica um registro existente na coluna ou colunas que definem o índice.

Use o INSERT IGNORE comando ao invés do INSERTcomando. Se um registro não duplica um registro existente, o MySQL o insere normalmente. Se o registro for duplicado, oIGNORE palavra-chave diz ao MySQL para descartá-lo silenciosamente sem gerar um erro.

O exemplo a seguir não apresenta erros e, ao mesmo tempo, também não insere registros duplicados.

mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
   -> VALUES( 'Jay', 'Thomas');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
   -> VALUES( 'Jay', 'Thomas');
Query OK, 0 rows affected (0.00 sec)

Use o REPLACEcomando em vez do comando INSERT. Se o registro for novo, ele é inserido da mesma forma que com INSERT. Se for uma duplicata, o novo registro substituirá o antigo.

mysql> REPLACE INTO person_tbl (last_name, first_name)
   -> VALUES( 'Ajay', 'Kumar');
Query OK, 1 row affected (0.00 sec)

mysql> REPLACE INTO person_tbl (last_name, first_name)
   -> VALUES( 'Ajay', 'Kumar');
Query OK, 2 rows affected (0.00 sec)

Os comandos INSERT IGNORE e REPLACE devem ser escolhidos de acordo com o comportamento de tratamento de duplicatas que você deseja efetuar. O comando INSERT IGNORE mantém o primeiro conjunto de registros duplicados e descarta o restante. O comando REPLACE mantém o último conjunto de duplicatas e apaga as anteriores.

Outra maneira de impor exclusividade é adicionar um UNIQUE índice em vez de uma PRIMARY KEY para uma tabela.

CREATE TABLE person_tbl (
   first_name CHAR(20) NOT NULL,
   last_name CHAR(20) NOT NULL,
   sex CHAR(10)
   UNIQUE (last_name, first_name)
);

Contando e Identificando Duplicados

A seguir está a consulta para contar registros duplicados com first_name e last_name em uma tabela.

mysql> SELECT COUNT(*) as repetitions, last_name, first_name
   -> FROM person_tbl
   -> GROUP BY last_name, first_name
   -> HAVING repetitions > 1;

Esta consulta retornará uma lista de todos os registros duplicados na tabela person_tbl. Em geral, para identificar conjuntos de valores que estão duplicados, siga as etapas fornecidas a seguir.

• Determine quais colunas contêm os valores que podem ser duplicados.

• Liste essas colunas na lista de seleção de coluna, junto com o COUNT(*).

• Liste as colunas no GROUP BY cláusula também.

• Adicione um HAVING cláusula que elimina os valores exclusivos exigindo que as contagens de grupo sejam maiores que um.

Eliminando Duplicados de um Resultado de Consulta

Você pode usar o DISTINCT junto com a instrução SELECT para descobrir os registros exclusivos disponíveis em uma tabela.

mysql> SELECT DISTINCT last_name, first_name
   -> FROM person_tbl
   -> ORDER BY last_name;

Uma alternativa ao comando DISTINCT é adicionar uma cláusula GROUP BY que nomeia as colunas que você está selecionando. Isso tem o efeito de remover duplicatas e selecionar apenas as combinações exclusivas de valores nas colunas especificadas.

mysql> SELECT last_name, first_name
   -> FROM person_tbl
   -> GROUP BY (last_name, first_name);

Removendo Duplicados Usando Substituição de Mesa

Se você tiver registros duplicados em uma tabela e desejar remover todos os registros duplicados dessa tabela, siga o procedimento fornecido a seguir.

mysql> CREATE TABLE tmp SELECT last_name, first_name, sex
   -> FROM person_tbl;
   -> GROUP BY (last_name, first_name);

mysql> DROP TABLE person_tbl;
mysql> ALTER TABLE tmp RENAME TO person_tbl;

Uma maneira fácil de remover registros duplicados de uma tabela é adicionar um INDEX ou uma PRIMARY KEY a essa tabela. Mesmo se esta tabela já estiver disponível, você pode usar esta técnica para remover os registros duplicados e você estará seguro no futuro também.

mysql> ALTER IGNORE TABLE person_tbl
   -> ADD PRIMARY KEY (last_name, first_name);

Se você pegar a entrada do usuário por meio de uma página da web e inseri-la em um banco de dados MySQL, há uma chance de que você se tenha deixado em aberto para um problema de segurança conhecido como SQL Injection. Este capítulo irá ensiná-lo como ajudar a evitar que isso aconteça e ajudá-lo a proteger seus scripts e instruções MySQL.

A injeção SQL geralmente ocorre quando você pede a entrada de um usuário, como seu nome e, em vez de um nome, eles fornecem uma instrução MySQL que você executará sem saber em seu banco de dados.

Nunca confie nos dados fornecidos por um usuário, processe esses dados somente após a validação; como regra, isso é feito por correspondência de padrões. No exemplo a seguir, o nome de usuário está restrito a caracteres alfanuméricos mais sublinhados e a um comprimento entre 8 e 20 caracteres - modifique essas regras conforme necessário.

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)) { $result = mysql_query("SELECT * FROM users WHERE username = $matches[0]");
} else  {
   echo "username not accepted";
}

Para demonstrar esse problema, considere o seguinte trecho.

// supposed input
$name = "Qadir'; DELETE FROM users;";
mysql_query("SELECT * FROM users WHERE name = '{$name}'");

A chamada de função deve recuperar um registro da tabela de usuários, onde a coluna de nome corresponde ao nome especificado pelo usuário. Em circunstâncias normais, $ name conteria apenas caracteres alfanuméricos e talvez espaços. Mas aqui, anexando uma consulta inteiramente nova a$name, a chamada para o banco de dados se transforma em um desastre. A consulta DELETE injetada remove todos os registros dos usuários.

Felizmente, se você usa MySQL, o mysql_query()função não permite o empilhamento de consultas ou a execução de várias consultas em uma única chamada de função. Se você tentar empilhar consultas, a chamada falhará.

No entanto, outras extensões de banco de dados PHP, como SQLite e PostgreSQL, felizmente executa consultas empilhadas, executando todas as consultas fornecidas em uma string e criando um sério problema de segurança.

Prevenção de injeção de SQL

Você pode lidar com todos os caracteres de escape de forma inteligente em linguagens de script como PERL e PHP. A extensão MySQL para PHP fornece a funçãomysql_real_escape_string() para escapar de caracteres de entrada que são especiais para MySQL.

if (get_magic_quotes_gpc()) {
   $name = stripslashes($name); } $name = mysql_real_escape_string($name); mysql_query("SELECT * FROM users WHERE name = '{$name}'");

O dilema LIKE

Para resolver o dilema LIKE, um mecanismo de escape personalizado deve converter% e _ caracteres fornecidos pelo usuário em literais. Usaraddcslashes(), uma função que permite especificar um intervalo de caracteres para o escape.

$sub = addcslashes(mysql_real_escape_string("%something_"), "%_"); // $sub == \%something\_
mysql_query("SELECT * FROM messages WHERE subject LIKE '{$sub}%'");

A maneira mais simples de exportar os dados de uma tabela para um arquivo de texto é usando o SELECT...INTO OUTFILE instrução que exporta um resultado de consulta diretamente para um arquivo no host do servidor.

Exportando dados com a instrução SELECT ... INTO OUTFILE

A sintaxe para esta declaração combina uma SELECT comando com INTO OUTFILE filenameno fim. O formato de saída padrão é o mesmo do comando LOAD DATA. Portanto, a seguinte declaração exporta otutorials_tbl mesa em /tmp/tutorials.txt como um arquivo delimitado por tabulação e encerrado por alimentação de linha.

mysql> SELECT * FROM tutorials_tbl 
   -> INTO OUTFILE '/tmp/tutorials.txt';

Você pode alterar o formato de saída usando várias opções para indicar como citar e delimitar colunas e registros. Para exportar a tabela tutorial_tbl em um formato CSV com linhas terminadas em CRLF, use o código a seguir.

mysql> SELECT * FROM passwd INTO OUTFILE '/tmp/tutorials.txt'
   -> FIELDS TERMINATED BY ',' ENCLOSED BY '"'
   -> LINES TERMINATED BY '\r\n';

o SELECT ... INTO OUTFILE tem as seguintes propriedades -

• O arquivo de saída é criado diretamente pelo servidor MySQL, então o nome do arquivo deve indicar onde você deseja que o arquivo seja gravado no host do servidor. Não existe uma versão LOCAL da declaração análoga àLOCAL versão de LOAD DATA.

• Você deve ter o MySQL FILE privilégio para executar o SELECT ... INTO declaração.

• O arquivo de saída ainda não deve existir. Isso evita que o MySQL destrua arquivos que podem ser importantes.

• Você deve ter uma conta de login no host do servidor ou alguma forma de recuperar o arquivo desse host. Caso contrário, oSELECT ... INTO OUTFILE o comando provavelmente não terá valor para você.

• No UNIX, o arquivo é criado world readablee é propriedade do servidor MySQL. Isso significa que, embora você possa ler o arquivo, talvez não consiga excluí-lo.

Exportando tabelas como dados brutos

o mysqldumpprograma é usado para copiar ou fazer backup de tabelas e bancos de dados. Ele pode escrever a saída da tabela como umRaw Datafile ou como um conjunto de INSERT instruções que recriam os registros na tabela.

Para despejar uma tabela como um arquivo de dados, você deve especificar um --tab opção que indica o diretório onde você deseja que o servidor MySQL grave o arquivo.

Por exemplo, para despejar o tutorials_tbl mesa do TUTORIALS banco de dados para um arquivo no /tmp diretório, use um comando conforme mostrado abaixo.

$ mysqldump -u root -p --no-create-info \
   --tab=/tmp tutorials tutorials_tbl
password ******

Exportando conteúdo de tabela ou definições em formato SQL

Para exportar uma tabela no formato SQL para um arquivo, use o comando mostrado abaixo.

$ mysqldump -u root -p TUTORIALS tutorials_tbl > dump.txt
password ******

Este será um arquivo criado com o conteúdo mostrado abaixo.

-- MySQL dump 8.23
--
-- Host: localhost    Database: TUTORIALS
---------------------------------------------------------
-- Server version       3.23.58

--
-- Table structure for table `tutorials_tbl`
--

CREATE TABLE tutorials_tbl (
   tutorial_id int(11) NOT NULL auto_increment,
   tutorial_title varchar(100) NOT NULL default '',
   tutorial_author varchar(40) NOT NULL default '',
   submission_date date default NULL,
   PRIMARY KEY  (tutorial_id),
   UNIQUE KEY AUTHOR_INDEX (tutorial_author)
) TYPE = MyISAM;

--
-- Dumping data for table `tutorials_tbl`
--

INSERT INTO tutorials_tbl 
   VALUES (1,'Learn PHP','John Poul','2007-05-24');
INSERT INTO tutorials_tbl 
   VALUES (2,'Learn MySQL','Abdul S','2007-05-24');
INSERT INTO tutorials_tbl 
   VALUES (3,'JAVA Tutorial','Sanjay','2007-05-06');

Para despejar várias tabelas, nomeie-as seguidas pelo argumento do nome do banco de dados. Para despejar um banco de dados inteiro, não nomeie nenhuma tabela após o banco de dados, conforme mostrado no bloco de código a seguir.

$ mysqldump -u root -p TUTORIALS > database_dump.txt
password ******

Para fazer backup de todos os bancos de dados disponíveis em seu host, use o código a seguir.

$ mysqldump -u root -p --all-databases > database_dump.txt
password ******

A opção --all-databases está disponível na versão MySQL 3.23.12. Este método pode ser usado para implementar uma estratégia de backup de banco de dados.

Copiando tabelas ou bancos de dados para outro host

Se você deseja copiar tabelas ou bancos de dados de um servidor MySQL para outro, use o mysqldump com o nome do banco de dados e o nome da tabela.

Execute o seguinte comando no host de origem. Isso irá despejar o banco de dados completo emdump.txt Arquivo.

$ mysqldump -u root -p database_name table_name > dump.txt
password *****

Você pode copiar o banco de dados completo sem usar um nome de tabela específico, conforme explicado acima.

Agora, use o arquivo ftp dump.txt em outro host e use o seguinte comando. Antes de executar este comando, certifique-se de ter criado database_name no servidor de destino.

$ mysql -u root -p database_name < dump.txt
password *****

Outra maneira de fazer isso sem usar um arquivo intermediário é enviar a saída do mysqldump diretamente pela rede para o servidor MySQL remoto. Se você puder se conectar a ambos os servidores a partir do host onde reside o banco de dados de origem, use o seguinte comando (certifique-se de ter acesso a ambos os servidores).

$ mysqldump -u root -p database_name \
   | mysql -h other-host.com database_name

No mysqldump, metade do comando se conecta ao servidor local e grava a saída do dump no pipe. A metade restante do comando se conecta ao servidor MySQL remoto no outro-host.com. Ele lê o pipe para entrada e envia cada instrução para o servidor other-host.com.

Existem duas maneiras simples no MySQL de carregar dados no banco de dados MySQL de um arquivo de backup anterior.

Importando dados com LOAD DATA

O MySQL fornece uma instrução LOAD DATA que atua como um carregador de dados em massa. Aqui está um exemplo de declaração que lê um arquivodump.txt do seu diretório atual e carrega-o na tabela mytbl no banco de dados atual.

mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl;

• Se o LOCAL palavra-chave não estiver presente, o MySQL procura o arquivo de dados no host do servidor usando o looking into absolute pathname, que especifica totalmente a localização do arquivo, começando na raiz do sistema de arquivos. O MySQL lê o arquivo no local fornecido.

• Por padrão, LOAD DATA assume que os arquivos de dados contêm linhas que são encerradas por avanços de linha (novas linhas) e que os valores de dados em uma linha são separados por tabulações.

• Para especificar um formato de arquivo explicitamente, use um FIELDS cláusula para descrever as características dos campos dentro de uma linha, e um LINEScláusula para especificar a seqüência de fim de linha. Os seguintesLOAD DATA instrução especifica que o arquivo de dados contém valores separados por dois pontos e linhas terminadas por retornos de carro e caractere de nova linha.

mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl
   -> FIELDS TERMINATED BY ':'
   -> LINES TERMINATED BY '\r\n';

• O comando LOAD DATA assume que as colunas do arquivo de dados têm a mesma ordem das colunas da tabela. Se isso não for verdade, você pode especificar uma lista para indicar em quais colunas da tabela as colunas do arquivo de dados devem ser carregadas. Suponha que sua tabela tenha colunas a, b e c, mas colunas sucessivas no arquivo de dados correspondem às colunas b, c e a.

Você pode carregar o arquivo conforme mostrado no bloco de código a seguir.

mysql> LOAD DATA LOCAL INFILE 'dump.txt' 
   -> INTO TABLE mytbl (b, c, a);

Importando dados com mysqlimport

O MySQL também inclui um programa utilitário chamado mysqlimport que atua como um invólucro em torno de LOAD DATA, para que você possa carregar os arquivos de entrada diretamente da linha de comando.

Para carregar dados do dump.txt para dentro mytbl, use o seguinte comando no prompt do UNIX.

$ mysqlimport -u root -p --local database_name dump.txt
password *****

Se você usar mysqlimport, as opções de linha de comando fornecem os especificadores de formato. omysqlimport comandos que correspondem aos dois anteriores LOAD DATA declarações parecem conforme mostrado no bloco de código a seguir.

$ mysqlimport -u root -p --local --fields-terminated-by = ":" \
   --lines-terminated-by = "\r\n"  database_name dump.txt
password *****

A ordem em que você especifica as opções não importa para mysqlimport, exceto que todas elas devem preceder o nome do banco de dados.

o mysqlimport declaração usa o --columns opção para especificar a ordem das colunas -

$ mysqlimport -u root -p --local --columns=b,c,a \
   database_name dump.txt
password *****

Tratamento de citações e personagens especiais

A cláusula FIELDS pode especificar outras opções de formato além TERMINATED BY. Por padrão, LOAD DATA assume que os valores não estão entre aspas e interpreta a barra invertida (\) como um caractere de escape para os caracteres especiais. Para indicar o caractere de citação de valor explicitamente, use oENCLOSED BYcomando. O MySQL removerá esse caractere do final dos valores de dados durante o processamento de entrada. Para alterar o caractere de escape padrão, useESCAPED BY.

Quando você especifica ENCLOSED BY para indicar que os caracteres de aspas devem ser removidos dos valores de dados, é possível incluir o caractere de aspas literalmente nos valores de dados duplicando-o ou precedendo-o com o caractere de escape.

Por exemplo, se as aspas e os caracteres de escape forem "e \, o valor de entrada "a""b\"c" será interpretado como a"b"c.

Para mysqlimport, as opções de linha de comando correspondentes para especificar valores de cotação e escape são --fields-enclosed-by e --fields-escaped-by.