Baixe Manual Prático do MySQL: Criando e Gerenciar Bancos de Dados e outras Notas de estudo em PDF para Informática, somente na Docsity!
Tutorial de MySQL Esta apostila fornece uma introdução ao MySQL por mostrar ao usuário como criar e gerenciar um banco de dados. MySQL é um programa interativo que permite você conectar com um servidor de MySQL, perguntar e ver os resultados. Também veremos MySQL utilizado em modo de lote: você coloca suas perguntas em um arquivo de antemão, e MySQL executa os conteúdos do arquivo. Ambos os caminhos de usar o MySQL são descritos aqui. Para ver uma lista de opções fornecidas por MySQL, invoque-o com -help: shell> mysql --help Esta apostila assume que o MySQL está instalado em sua máquina, e que um servidor de MySQL está disponível para que possa conectar. A apostila descreve o processo inteiro de como criar e usar um banco de dados. Conectando e desconectando do servidor Para conectar ao servidor, você usualmente necessitará fornecer um usuário ao MySQL e, mais provavelmente, uma senha. Se o servidor continua numa máquina que não tem onde se registrar, também necessitará especificar um hostname. Sabendo os parâmetros próprios, você poderá se conectar: shell> mysql -h host -u user -p Enter password: ******** O ******** representa sua senha; entre com a senha quando MySQL exibir Enter password: prompt. Se daquela estação, você deveria ver alguma informação de introdução seguida por uma mysql> prompt: shell> mysql -h host -u user -p Enter password: ******** Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 459 to server version: 3.22.20a-log Tipo "help" para ajuda. mysql> O prompt diz que você está pronto para entrar com os comandos. Algumas instalações do MySQL permite aos usuários conectar com o servidor e continuar como anfitrião local. Se isto é o caso em sua máquina, você deveria ser capaz de conectar com o servidor ao invocar o MySQL sem quaisquer opções: shell> mysql Depois que está conectado, você pode desconectar a qualquer momento, é só digitar QUIT no mysql> prompt: mysql> QUIT Bye Você também pode desconectar por control-D. Na maioria dos exemplos nas seguintes seções, assumem que você está conectado ao servidor.
Eles indicam isto por: mysql> prompt. Entrando e perguntando Neste ponto, é mais importante descobrir como emitir perguntas do que criar tabelas, carregar e recuperar dados. Esta seção descreve os princípios básicos de como entrar com os comandos, usando várias perguntas. Você pode experimentar familiarizando com os trabalhos do MySQL. Aqui é um comando simples que pergunta ao servidor o número de sua versão e a data corrente. mysql> SELECT VERSION(), CURRENT_DATE; +--------------+--------------+ | version() | CURRENT_DATE | +--------------+--------------+ | 3.22.20a-log | 1999-03-19 | +--------------+--------------+ 1 row in set (0.01 sec) mysql> Esta pergunta ilustra várias coisas sobre MySQL:
- Um comando normalmente consiste de uma declaração do SQL seguida por um ponto-e-vírgula. (Há algumas exceções onde um ponto-e-vírgula não são necessário. QUIT, mencionado anteriormente, é um deles.)
- Quando você emite um comando, MySQL envia ao servidor para execução e exibe os resultados, então exibe mysql>, para indicar que está pronto para outro comando.
- MySQL exibe a saída da pergunta como uma tabela (filas e colunas). A primeira fila contem rótulos às colunas. As demais filas são os resultados da pergunta. Normalmente, os rótulos da coluna são os nomes das colunas que traz das tabelas do banco de dados. Se você está recuperando o valor de uma expressão, em vez de uma coluna de tabela, MySQL rotula a coluna usando a expressão que foi usada.
- MySQL mostra quantas filas foram exibidas, e quanto tempo a pergunta levou para ser executada, dando uma idéia rude de performance do servidor. Esses valores são imprecisos porque eles representam tempo de relógio de parede (não CPU ou tempo de máquina), e porque eles são afetados por certos tipos de fatores. Palavras chaves podem ser inseridas em qualquer caixa de entrada. As seguintes perguntas são equivalente: mysql> SELECT VERSION(), CURRENT_DATE; mysql> select version(), current_date; mysql> SeLeCt vErSiOn(), current_DATE; Aqui é outra pergunta. Isto demonstra que você pode usar MySQL como uma simples calculadora: mysql> SELECT SIN(PI()/4), (4+1)5; +-------------+---------+ | SIN(PI()/4) | (4+1)5 | +-------------+---------+ | 0.707107 | 25 | +-------------+---------+ Os comandos mostrados têm estado relativamente em declarações de linhas únicas e curtas.
Esperando para próxima linha, colecionando um fio que começa com uma citação duplicada (""") Linhas múltiplas de declarações comuns ocorrem por acaso, quando você pretende emitir um comando em uma única linha, mas esquece o ponto-e-vírgula. Neste caso, MySQL espera para mais entrada: mysql> SELECT USER() -> Se isto acontecer (você pensa que entrou com uma declaração mas a unicamente a resposta é um -> prompt), mas provavelmente, MySQL está esperando o ponto-e-vírgula. Entre com um ponto-e-vírgula para completar a declaração, e MySQL executará: mysql> SELECT USER() -> ; +--------------------+ | USER() | +--------------------+ | joesmith@localhost | +--------------------+ O '> e "> prompts ocorrem durante coleção de fio. No MySQL, pode escrever fios circundados por um "'" ou """ caracteres (por exemplo, 'hello' ou "adeus"), e MySQL deixa que você entre com os fios que transpõem linhas múltiplas. Quando você vê um '> ou "> prompt, este meio que tem de entrar com uma linha contendo um fio que começa com caracteres: "'" ou "", não tem ainda que entrar com a citação que termina o fio. Seria bom se está realmente entrando com uma linha múltipla de fio, mas como provavelmente é isso? Mais freqüentemente, o '> e "> prompts indicam que você descuidou e deixou fora um caracter de citação. Por exemplo: mysql> SELECT * FROM my_table WHERE name = "Smith AND age < 30; "> Se você ao entrar com a declaração SELECT, ele acessa, volta e se você ficar esperando o resultado e nada acontecer, ao invés de admirar, note a pista fornecida pelo "> prompt. Isto diz que MySQL está esperando ver o final de um fio. Neste ponto, o que deve ser feito? É simples, é só cancelar o comando. Entretanto, não pode ser somente \c, porque MySQL interpreta isto, como a separação do fio que está colecionando. Ao invés, de entrar somente com o fechamento de caracter (assim MySQL saberá que você terminou o fio), entre com "\c: mysql> SELECT * FROM my_table WHERE name = "Smith AND age < 30; "> "\c mysql> As mudanças do prompt retornam para mysql>, indicando que MySQL está pronto para um novo comando. Isto é importante, para saber o que '> e "> prompts expressam, porque se você entrar incorretamente com um fio, mais além, você digita a vontade e parece que MySQL ignorou, incluindo uma linha contendo QUIT, isto pode ser completamente confuso, se você não sabe o que necessita para fornecer a citação de término antes que possa cancelar o comando corrente. Exemplos de perguntas comuns
Aqui segue exemplos de como resolver alguns dos problemas mais comuns do MySQL. Algum dos exemplos usam a tabela de compras, coloque os preços de cada artigo (número de item) de cada negociante. Supondo que cada negociante tem um preço fixo por artigo, então (item, negociante) é uma chave primária aos registros. Você pode criar a tabela de exemplo como: CREATE TABLE shop ( article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL, dealer CHAR(20) DEFAULT '' NOT NULL, price DOUBLE(16,2) DEFAULT '0.00' NOT NULL, PRIMARY KEY(article, dealer)); INSERT INTO shop VALUES (1,'A',3.45),(1,'B',3.99),(2,'A',10.99),(3,'B',1.45),(3,'C',1.69), (3,'D',1.25),(4,'D',19.95); Assim os dados de exemplo estarão: SELECT * FROM shop +---------+--------+-------+ | article | dealer | price | +---------+--------+-------+ | 0001 | A | 3.45 | | 0001 | B | 3.99 | | 0002 | A | 10.99 | | 0003 | B | 1.45 | | 0003 | C | 1.69 | | 0003 | D | 1.25 | | 0004 | D | 19.95 | +---------+--------+-------+ O valor máximo de uma coluna "Qual é o artigo que tem o preço mais alto?" SELECT MAX(article) AS article FROM shop +---------+ | article | +---------+ | 4 | +---------+ A fila da coluna com o número máximo "Encontre o número do negociantes, e avalie quem tem o artigo mais caro." No ANSI SQL isto é facilmente feito com um sub-query: SELECT article, dealer, price FROM shop WHERE price=(SELECT MAX(price) FROM shop)
CREATE TEMPORARY TABLE tmp ( article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL, price DOUBLE(16,2) DEFAULT '0.00' NOT NULL); LOCK TABLES article read; INSERT INTO tmp SELECT article, MAX(price) FROM shop GROUP BY article; SELECT article, dealer, price FROM shop, tmp WHERE shop.article=tmp.article AND shop.price=tmp.price; UNLOCK TABLES; DROP TABLE tmp; Se você usar uma tabela TEMPORÁRIA, você deve também fechar o "tmp" tabela. "Isto pode ser feito com uma pergunta única?" Sim, mas pode usar um truque ineficiente que é chamado de "MAX-CONCAT trick": SELECT article, SUBSTRING( MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 7) AS dealer, 0.00+LEFT( MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 6) AS price FROM shop GROUP BY article; +---------+--------+-------+ | article | dealer | price | +---------+--------+-------+ | 0001 | B | 3.99 | | 0002 | A | 10.99 | | 0003 | C | 1.69 | | 0004 | D | 19.95 | +---------+--------+-------+ Usando chaves estrangeiras Você não necessita de chaves estrangeiras para unir 2 tabelas. O MySQL não faz a checagem de certificar que as chaves da tabela são referências e isto não é feito automaticamente apagando as filas da tabela com uma definição de chave estrangeira. Se você usa as chaves normais, ele trabalhará perfeitamente. CREATE TABLE persons ( id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT, name CHAR(60) NOT NULL, PRIMARY KEY (id) ); CREATE TABLE shirts ( id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT, style ENUM('t-shirt', 'polo', 'dress') NOT NULL, color ENUM('red', 'blue', 'orange', 'white', 'black') NOT NULL,
owner SMALLINT UNSIGNED NOT NULL REFERENCES persons, PRIMARY KEY (id) ); INSERT INTO persons VALUES (NULL, 'Antonio Paz'); INSERT INTO shirts VALUES (NULL, 'polo', 'blue', LAST_INSERT_ID()), (NULL, 'dress', 'white', LAST_INSERT_ID()), (NULL, 't-shirt', 'blue', LAST_INSERT_ID()); INSERT INTO persons VALUES (NULL, 'Lilliana Angelovska'); INSERT INTO shirts VALUES (NULL, 'dress', 'orange', LAST_INSERT_ID()), (NULL, 'polo', 'red', LAST_INSERT_ID()), (NULL, 'dress', 'blue', LAST_INSERT_ID()), (NULL, 't-shirt', 'white', LAST_INSERT_ID()); SELECT * FROM persons; +----+---------------------+ | id | name | +----+---------------------+ | 1 | Antonio Paz | | 2 | Lilliana Angelovska | +----+---------------------+ SELECT * FROM shirts; +----+---------+--------+-------+ | id | style | color | owner | +----+---------+--------+-------+ | 1 | polo | blue | 1 | | 2 | dress | white | 1 | | 3 | t-shirt | blue | 1 | | 4 | dress | orange | 2 | | 5 | polo | red | 2 | | 6 | dress | blue | 2 | | 7 | t-shirt | white | 2 | +----+---------+--------+-------+ SELECT s.* FROM persons p, shirts s WHERE p.name LIKE 'Lilliana%' AND s.owner = p.id AND s.color <> 'white'; +----+-------+--------+-------+ | id | style | color | owner | +----+-------+--------+-------+ | 4 | dress | orange | 2 | | 5 | polo | red | 2 | | 6 | dress | blue | 2 | +----+-------+--------+-------+ Pesquisando em duas chaves
Database changed Note que USE, QUIT, não requerem um ponto-e-vírgula. (Você pode terminar tais declarações com um ponto-e-vírgula) A declaração USE também é especial em outro caminho: isto deve-se a dar em uma única linha. Você pode usar o banco de dados test com os exemplos que seguem, mas se você criar algo no banco de dados, pode ser removido por qualquer um que tenha acesso. Por esta razão, você deveria pedir ao seu administrador do MySQL, permissão para usar um banco de dados. Suponha que você deseja chamar seu menagerie. O administrador necessita executar um comando: mysql> GRANT ALL ON menagerie.* TO your_mysql_name; onde your_mysql_name é o nome do usuário do MySQL designado a você. Selecionando um banco de dados Se o administrador criar para você seu banco de dados com suas permissões, você pode começar a usá-lo. De outro modo, você mesmo necessita criá-lo. mysql> CREATE DATABASE menagerie; Sob Unix, nomes de banco de dados são caso sensível (diferente de palavras chaves do SQL), assim você deve sempre referir para seu banco de dados como menagerie, não como Menagerie, MENAGERIE ou alguma outra variante. Isto também é vale para nomes de tabela. (Sob o Windows, esta restrição não aplica, embora você deva referir-se a bancos de dados e tabelas usando o mesmo lettercase por toda pergunta dada.) Criando um banco de dados, você não o seleciona para uso, deve fazer isto explicitamente. Para fazer o menagerie do banco de dados corrente, use este comando: mysql> USE menagerie Database changed Seu banco de dados necessita ser criado uma unicamente vez, mas deve selecioná-lo o uso a cada vez que começar uma sessão do MySQL. Você pode fazer isto ao usar uma declaração de USE como mostrada acima. Alternativamente, você pode selecionar o banco de dados na linha de comando, quando você invocar MySQL. Somente vai especificar seu nome depois de quaisquer parâmetros de conexão que poderá ser necessário fornecer. Por exemplo: shell> mysql -h host -u user -p menagerie Enter password: ******** Note que menagerie não é sua senha no comando. Se você deseja fornecer sua senha na linha de comando depois da opção -p, você deve fazer não intervindo espaço (e.g., como -pmypassword, não como -p mypassword). Entretanto, colocar sua senha na linha de comando não é recomendada, porque impede ações que expõe a outros usuários registrados em sua máquina. Criando uma tabela Criar um banco de dados é a parte mais fácil, mas neste ponto ele está vazio, com SHOW TABLES mostrará: mysql> SHOW TABLES; Empty set (0.00 sec)
