Docsity
Docsity

Prepare-se para as provas
Prepare-se para as provas

Estude fácil! Tem muito documento disponível na Docsity


Ganhe pontos para baixar
Ganhe pontos para baixar

Ganhe pontos ajudando outros esrudantes ou compre um plano Premium


Guias e Dicas
Guias e Dicas


Tutorial de MySQL - Apostilas - Informática Part3, Notas de estudo de Informática

Apostilas de Informática sobre Tutorial de MySQL, Conectando e desconectando do servidor, Tipo "help" para ajuda, Entrando e perguntando, Exemplos de perguntas comuns, Carregando dados dentro uma tabela.

Tipologia: Notas de estudo

2013

Compartilhado em 27/08/2013

Garoto
Garoto 🇪🇸

4.6

(121)

1 / 10

Toggle sidebar

Esta página não é visível na pré-visualização

Não perca as partes importantes!

bg1
Trabalhando com valores NULOS
O valor NULL pode ser surpreendente até você se acostumar a isto. Conceitualmente,
valores NULL são valores desconhecidos e isto é tratado diferentemente dos outros valores.
Para testar NULL, você não pode usar os operadores de comparação de aritmética tal
como =, < ou !=. Para demonstrar isto, tenta a seguinte pergunta:
mysql> SELECT 1 = NULL, 1 != NULL, 1 < NULL, 1 > NULL;
+----------+-----------+----------+----------+
| 1 = NULL | 1 != NULL | 1 < NULL | 1 > NULL |
+----------+-----------+----------+----------+
| NULL | NULL | NULL | NULL |
+----------+-----------+----------+----------+
Claramente você obtem nenhum resultado significativos destas comparações.
Use o operadores IS NULL e IS NOT NULL:
mysql> SELECT 1 IS NULL, 1 IS NOT NULL;
+-----------+---------------+
| 1 IS NULL | 1 IS NOT NULL |
+-----------+---------------+
| 0 | 1 |
+-----------+---------------+
No MySQL, 0 são valores falsos e 1 são valores verdadeiros.
Este tratamento especial de NULL é por que isto foi necessário para determinar
se os animais não estam mortos, usando death IS NOT NULL ao invés de death != NULL.
Unindo Modelo
MySQL fornece um modelo do SQL padronizado unindo assim um formulário de modelo
baseado em expressões regulares parecidas com aquelas utilizadas por utilitários de
Unix tal como vi, grep e sed.
Modelo do SQL permite você usar "_" para unir qualquer caracter único, e "%" para unir
um número arbitrário de caracteres (incluindo zero caracteres). No MySQL, modelos
do SQL são caso insensível por default. Alguns exemplos são mostrados baixo. Note
que você não usa = ou != quando você usa modelos do SQL; use o GOSTADO DE ou NÃO
operadores de comparação IGUAIS ao invés.
Para encontrar nomes começam com "b":
mysql> SELECT * FROM pet WHERE name LIKE "b%";
+--------+--------+---------+------+------------+------------+
| name | owner | species | sex | birth | death |
+--------+--------+---------+------+------------+------------+
| Buffy | Harold | dog | f | 1989-05-13 | NULL |
| Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 |
+--------+--------+---------+------+------------+------------+
Para encontrar nomes finalizando com "%fy":
pf3
pf4
pf5
pf8
pf9
pfa

Pré-visualização parcial do texto

Baixe Tutorial de MySQL - Apostilas - Informática Part3 e outras Notas de estudo em PDF para Informática, somente na Docsity!

Trabalhando com valores NULOS O valor NULL pode ser surpreendente até você se acostumar a isto. Conceitualmente, valores NULL são valores desconhecidos e isto é tratado diferentemente dos outros valores. Para testar NULL, você não pode usar os operadores de comparação de aritmética tal como =, < ou !=. Para demonstrar isto, tenta a seguinte pergunta: mysql> SELECT 1 = NULL, 1 != NULL, 1 < NULL, 1 > NULL; +----------+-----------+----------+----------+ | 1 = NULL | 1 != NULL | 1 < NULL | 1 > NULL | +----------+-----------+----------+----------+ | NULL | NULL | NULL | NULL | +----------+-----------+----------+----------+ Claramente você obtem nenhum resultado significativos destas comparações. Use o operadores IS NULL e IS NOT NULL: mysql> SELECT 1 IS NULL, 1 IS NOT NULL; +-----------+---------------+ | 1 IS NULL | 1 IS NOT NULL | +-----------+---------------+ | 0 | 1 | +-----------+---------------+ No MySQL, 0 são valores falsos e 1 são valores verdadeiros. Este tratamento especial de NULL é por que isto foi necessário para determinar se os animais não estam mortos, usando death IS NOT NULL ao invés de death != NULL. Unindo Modelo MySQL fornece um modelo do SQL padronizado unindo assim um formulário de modelo baseado em expressões regulares parecidas com aquelas utilizadas por utilitários de Unix tal como vi, grep e sed. Modelo do SQL permite você usar "_" para unir qualquer caracter único, e "%" para unir um número arbitrário de caracteres (incluindo zero caracteres). No MySQL, modelos do SQL são caso insensível por default. Alguns exemplos são mostrados baixo. Note que você não usa = ou != quando você usa modelos do SQL; use o GOSTADO DE ou NÃO operadores de comparação IGUAIS ao invés. Para encontrar nomes começam com "b": mysql> SELECT * FROM pet WHERE name LIKE "b%"; +--------+--------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+------------+ | Buffy | Harold | dog | f | 1989-05-13 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +--------+--------+---------+------+------------+------------+ Para encontrar nomes finalizando com "%fy":

mysql> SELECT * FROM pet WHERE name LIKE "%fy"; +--------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+-------+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +--------+--------+---------+------+------------+-------+ Para encontrar nomes contendo uns "w": mysql> SELECT * FROM pet WHERE name LIKE "%w%"; +----------+-------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +----------+-------+---------+------+------------+------------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL | +----------+-------+---------+------+------------+------------+ Para encontrar nomes contendo extamente cinco caracteres, usam os caracteres de modelo "_": mysql> SELECT * FROM pet WHERE name LIKE "_____"; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+ O outro tipo de modelo fornecido por MySQL usa expressões regulares. Quando você testa este tipo de modelo, usa os operadores REGEXP e NOT REGEXP (ou RLIKE e NOT RLIKE, que são sinônimos). Algumas características expressões regulares são:

  • "." casa qualquer caracter único.
  • Uma classe de caracter "[...]" une qualquer caracter dentro dos suportes. Por exemplo, "[abc]" une "a", "b" ou "c". Para especificar uma série de caracteres, usam um traço. "[a-z]" une qualquer letra minúscula, ao passo que "[0-9]" une qualquer dígito.
  • "" une zero ou mais solicitações. Por exemplo, "x" une qualquer número de "x" caracteres, "[0-9]" une qualquer número de dígitos, e "." une qualquer número de algo.
  • Expressões Regulares são casos sensíveis, mas você pode usar uma classe de caracter para unir ambos lettercases. Por Exemplo, "[aA]" une letra minúscula ou maiúscula "a" e "[a-zA-Z]" une qualquer letra em um caso ou outro.
  • O modelo ocorre em qualquer parte na existência do valor testado ( modelos do SQL unem unicamente os valores inteiro).
  • Para ancorar um modelo de modo que isto deve unir o começo ou término da existência do valor testado, use "^" no começo ou "$" no final do modelo. Para trabalho de expressões regulares, as perguntas LIKE e REGEXP podem ser usadas abaixo: Para encontrar nomes que começam com "b", para unir o começo do nome use "^" e "[bB]" para unir letra minúscula com outra maiúscula "b": mysql> SELECT * FROM pet WHERE name REGEXP "^[bB]"; +--------+--------+---------+------+------------+------------+ | name | owner | species | sex | birth | death |

saber quantos animais de estimação você tem, ou quantos animais de estimação cada dono tem, ou você pôde desejar desempenhar várias espécies de censos em seus animais. Contando o número total de animais você faz a mesma pergunta de "quantas filas tem na tabela de animal de estimação?" porque há um registro, por cada animal de estimação. A função COUNT() conta o número de resultados não NULOS, assim a pergunta para contar seus de animais é: mysql> SELECT COUNT() FROM pet; +----------+ | COUNT() | +----------+ | 9 | +----------+ Mais, você recuperou os nomes das pessoas que possuíam animais de estimação. Você pode usar COUNT() se você deseja descobrir quantos animais de estimação cada dono tem: mysql> SELECT owner, COUNT() FROM pet GROUP BY owner; +--------+----------+ | owner | COUNT() | +--------+----------+ | Benny | 2 | | Diane | 2 | | Gwen | 3 | | Harold | 2 | +--------+----------+ Note o uso de GROUP BY para agrupar juntamente todos os registros de cada dono. Sem isto, você obtem uma mensagem de erro: mysql> SELECT owner, COUNT(owner) FROM pet; ERROR 1140 at line 1: Mixing of GROUP columns (MIN(),MAX(),COUNT()...) with no GROUP columns is illegal if there is no GROUP BY clause COUNT() e AGROUP BY são úteis para caracterizar seus dados em vários caminhos. Os seguintes exemplos mostram caminhos diferentes para desempenhar operações de censo animais. Número de animais por espécie: mysql> SELECT species, COUNT() FROM pet GROUP BY species; +---------+----------+ | species | COUNT() | +---------+----------+ | bird | 2 | | cat | 2 | | dog | 3 | | hamster | 1 | | snake | 1 | +---------+----------+ Número de animais por sexo: mysql> SELECT sex, COUNT() FROM pet GROUP BY sex; +------+----------+ | sex | COUNT() |

| NULL | 1 |

| f | 4 | | m | 4 | +------+----------+ (Nesta saída, NULL indica "sexo desconhecido.") Número de animais por combinação de espécie e sexo: mysql> SELECT species, sex, COUNT() FROM pet GROUP BY species, sex; +---------+------+----------+ | species | sex | COUNT() | +---------+------+----------+ | bird | NULL | 1 | | bird | f | 1 | | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | | hamster | f | 1 | | snake | m | 1 | +---------+------+----------+ Para uma tabela inteira você usa COUNT(). Por exemplo, a pergunta prévia, quando desempenhada somente nos cães e gatos: mysql> SELECT species, sex, COUNT() FROM pet -> WHERE species = "dog" OR species = "cat" -> GROUP BY species, sex; +---------+------+----------+ | species | sex | COUNT() | +---------+------+----------+ | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | +---------+------+----------+ Ou, se você desejar o número de animais por sexo, que contenha valores conhecidos para o sexo dos animais: mysql> SELECT species, sex, COUNT() FROM pet -> WHERE sex IS NOT NULL -> GROUP BY species, sex; +---------+------+----------+ | species | sex | COUNT() | +---------+------+----------+ | bird | f | 1 | | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | | hamster | f | 1 | | snake | m | 1 | +---------+------+----------+

aniversário Primeiro aniversário Carregue os registros: mysql> LOAD DATA LOCAL INFILE "event.txt" INTO TABLE event; Baseado no que você já aprendeu nas perguntas, continuando na tabela de animal de estimação, agora você é capaz de desempenhar recuperações nos registros da tabela de evento; os princípios são os mesmos. Mas quando a tabela de evento é por si mesmo insuficiente para responder as perguntas você pôde perguntar? Suponha que deseja descobrir as idades de cada animal de estimação quando eles tiveram suas crias. A tabela de evento indica quando isto ocorreu, mas para calcular a idade da mãe, você necessita a data de nascimento que está armazenado na tabela de animal de estimação, você necessita de ambas tabelas: mysql> SELECT pet.name, (TO_DAYS(date) - TO_DAYS(birth))/365 AS age, remark -> FROM pet, event -> WHERE pet.name = event.name AND type = "litter"; +--------+------+-----------------------------+ | name | age | remark | +--------+------+-----------------------------+ | Fluffy | 2.27 | 4 kittens, 3 female, 1 male | | Buffy | 4.12 | 5 puppies, 2 female, 3 male | | Buffy | 5.10 | 3 puppies, 3 female | +--------+------+-----------------------------+ Há várias coisas para notar sobre esta pergunta:

  • A cláusula FROM lista duas tabelas porque a pergunta necessita puxar informação de ambas.
  • Quando combina informação de tabelas múltiplas, você necessita registrar em uma tabela que pode ser a união do outro registro. Isto é fácil porque ambos tem uma coluna de nome. A cláusula WHERE pergunta para as duas tabelas os valores do nome.
  • A coluna de nome ocorre em ambas tabelas, você deve ser específico sobre que tabela você está se referindo à coluna. Você tem duas tabelas diferentes para uni-las. Às vezes isto é útil para unir uma tabela para si mesmo, se você deseja comparar registros em uma tabela com outros registros naquela mesma tabela. Por exemplo, para encontrar o sexo entre seus animais de estimação, você pode unir a tabela de animal de estimação com si mesmo para juntar os masculinos e as fêmeas da mesma espécie: mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species -> FROM pet AS p1, pet AS p -> WHERE p1.species = p2.species AND p1.sex = "f" AND p2.sex = "m"; +--------+------+--------+------+---------+ | name | sex | name | sex | species | +--------+------+--------+------+---------+ | Fluffy | f | Claws | m | cat | | Buffy | f | Fang | m | dog | | Buffy | f | Bowser | m | dog | +--------+------+--------+------+---------+ Obtendo informação sobre bancos de dados e tabelas

Se você esquecer o nome de um banco de dados ou tabela, ou a estrutura de uma tabela (como suas colunas são chamadas). MySQL resolve este problema através de várias declarações que fornecem informação sobre os bancos de dados e tabelas. Você já viu SHOW DATABASES, que lista os bancos de dados administrados pelo servidor. Para descobrir qual o banco de dados corrente foi selecionado, usa a função DATABASES(): mysql> SELECT DATABASE(); +------------+ | DATABASE() | +------------+ | menagerie | +------------+ Se você não tem um banco de dados selecionado ainda, o resultado é vazio. Para descobrir que tabelas o banco de dados corrente contem ou quando você não está seguro sobre o nome de uma tabela, use este comando: mysql> SHOW TABLES; +---------------------+ | Tables in menagerie | +---------------------+ | event | | pet | +---------------------+ Se você deseja descobrir sobre a estrutura de uma tabela, o comando DESCRIBE é útil; isto exibe informação sobre cada coluna de uma tabela: mysql> DESCRIBE pet; +---------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +---------+-------------+------+-----+---------+-------+ | name | varchar(20) | YES | | NULL | | | owner | varchar(20) | YES | | NULL | | | species | varchar(20) | YES | | NULL | | | sex | char(1) | YES | | NULL | | | birth | date | YES | | NULL | | | death | date | YES | | NULL | | +---------+-------------+------+-----+---------+-------+ Field indica o nome de coluna, Type é o tipo de dados, Null indica que não importa se a coluna pode conter valores NULOS, Key indica que não importa se a coluna é ordenada e Default especifica valor de default da coluna. Se ordenou uma tabela, SHOW INDEX FROM tbl_name produzimos informação sobre elas. Usando MySQL em modo lote Você e o MySQL utilizaram entrar com as perguntas e ver os resultados. Você também pode também executar MySQL em modo lote. Para fazer isto, coloque os comandos que você deseja num arquivo, então peça ao MySQL para ler a entrada do arquivo: shell> mysql < batch-file Se você necessita especificar parâmetros de conexão na linha de comando, use: