Gerenciando banco de dados com MySQL (parte 2)

Autor: Jefferson Estanislau da Silva <jeffestanislau at hotmail.com> Data: 11/01/2004 Introduo Na primeira parte do artigo:

Gerenciando banco de dados com MySQL (Parte 1)

expliquei o que um banco de dados, como adquirir e instalar o MySQL e os primeiros passos no uso dos comandos para se comear a elaborar uma estrutura de um BD. Nesta segunda parte, voc ver opes que lhe ajudam a manter a integridade em suas tabelas, assim como mais opes para o uso da clusula "Select" e por fim como manter a segurana no acesso ao banco de dados. Mas vamos ao que interessa, comecem a conferir o artigo!

Restries de integridade
So regras que servem para prevenir a entrada de informaes invlidas pelos usurios. Para isso, o SGBD prov ferramentas para regras de integridade, afim de evitar a inconsistncia dos dados que nele sero armazenados.

Valores nulos
Para evitar que um campo possa conter valor nulo (ou no conter valor algum) deve-se utilizar a clusula NOT NULL aps a definio da coluna, como j demonstrado anteriormente: mysql> CREATE TABLE alunos ( -> nome VARCHAR(50) NOT NULL, // no aceita valor nulo -> endereco VARCHAR(50) NULL // aceita valor nulo );

Valores Duplicados
H situaes onde o valor armazenado em um campo de um registro deve ser nico em relao a todos os registros da tabela, para isso usamos a clusula UNIQUE: mysql> CREATE TABLE alunos ( -> nome VARCHAR(50) NOT NULL, -> CPF INT(11) UNIQUE, // no deve haver dois registro com o mesmo CPF ... );

Valores Invlidos
H situaes onde o valor de um campo deve obedecer a uma regra. Para que ele fique restrito a um conjunto de valores, utiliza-se a clusula CHECK: mysql> CREATE TABLE alunos ( -> nome VARCHAR(50) NOT NULL, -> sexo CHAR(1) CHECK(sexo IN ("M", "F")), // obriga usar M ou F ... );

Valores default
Pode-se definir um valor padro para um campo acrescentando sua definio a clusula DEFAULT: mysql> CREATE TABLE alunos ( -> nome VARCHAR(50) NOT NULL, -> cidade VARCHAR(30) DEFAULT "Nova Friburgo") ...

Campo chave ou chave primria

Como j comentado anteriormente, o campo chave um campo muito importante para nossa tabela. Sua funo identificar univocamente uma linha do registro da tabela. Toda tabela deve possuir um campo chave. Quando este definido, fica implcito as clusulas UNIQUE e NOT NULL para este campo, no sendo necessrio a especificao destas. mysql> CREATE TABLE alunos ( -> matricula VARCHAR(5) NOT NULL, -> nome VARCHAR(50) NOT NULL, -> PRIMARY KEY(matricula)); // define o campo matricula como chave

Visualizando dados de maneira mais organizada

Como j vimos, o comando SELECT o responsvel por fazer a exibio dos dados registrados em nossas tabelas, veremos agora como utilizar uma melhor aplicao deste recurso.

Evitando a exibio de linhas duplicadas

Para que isso no ocorra, necessrio a indicao da palavra DISTINCT imediatamente aps o comando SELECT: mysql> SELECT DISTINCT cidade FROM alunos;

Ordenando os dados
J vimos anteriormente que para isto necessrio usar a clusula ORDER BY. Por default est clusula ordena os dados em ASCENDING (crescente), mas se voc necessitar visualizar os dados na ordem decrescente, utilize as siglas DESC aps a clusula:

mysql> SELECT nome FROM alunos ORDER BY nome DESC;

Utilizando alias (apelidos)

Existem duas maneiras de se utilizar os Alias (apelidos) em uma clusula do MySQL, so elas: apelido para o nome exibido no ttulo da coluna de uma tabela e apelido para simplificar um nome de tabela que ser constantemente utilizado em uma clusula SELECT. Exemplos 1: apelido para o ttulo mysql> SELECT nome FROM ALUNOS;
+-------------------------------+ | nome | +-------------------------------+ | Jefferson Estanislau da Silva | | Leila Maria Muniz da Silva | | Victor Estanislau da Silva | +-------------------------------+

// observe que apresentado o nome real da coluna. mysql> SELECT nome AS INSCRITOS FROM ALUNOS;
+-------------------------------+ | INSCRITOS | +-------------------------------+ | Jefferson Estanislau da Silva | | Leila Maria Muniz da Silva | | Victor Estanislau da Silva | +-------------------------------+

//observe que o nome real foi substituido pelo apelido Inscritos. Exemplo 2: apelido para uma tabela constante em uma clusula: mysql> SELECT ALUNOS.nome, CURSOS.nomecurso FROM ALUNOS, CURSOS -> where ALUNOS.codcurso = CURSOS.codcurso -> and ALUNOS.cidade='Nova Friburgo'; // observe que o nome das tabelas ALUNOS e CURSO so repetidos constantemente dentro desta clusula. mysql> SELECT A.nome, C.nomecurso FROM ALUNOS AS A, CURSOS AS C -> where A.codcurso = C.codcurso -> and A.cidade='Nova Friburgo'; // observe que foi utilizado o apelido A para AlUNOS e C para CURSOS, simplificando assim o cdigo. // As duas formas apresentam este resultado:
+-------------------------------+--------------------+ | nome | nomecurso | +-------------------------------+--------------------+ | Jefferson Estanislau da Silva | Ensino Medio | | Leila Maria Muniz da Silva | Ensino Medio | | Victor Estanislau da Silva | Ensino Fundamental | +-------------------------------+--------------------+

Utilizando condies
J vimos que para que se faa o uso de condies deve se usar o comando WHERE. Veremos agora vrias formas de se aplicar estas condies. NOTA: possvel utilizar operadores de comparao lgica, estes esto divididos em duas classes: Operadores de linha nica = igual a ! diferente de > maior que >= maior ou igual a < menor que <= menor ou igual a mysql> SELECT nome FROM alunos WHERE matricula='300'; Operadores de vrias linhas AND e OR ou NOT no mysql> SELECT nome FROM aluno WHERE cidade='Salvador' AND matricula='300'; mysql> SELECT nome FROM aluno WHERE cidade='Salvador' OR matricula='300'; Precedncia de operadores 1. 2. 3. 4. 5. 6. Uma clusula WHERE pode combinar vrios operadores AND e OR. O operador AND tem maior precedncia que o operador OR. Os operadores de comparao tem maior precedncia que os conectivos AND e OR. Todos os operadores de comparao tem a mesma precedncia. Operadores de igual precedncia so calculados da esquerda para a direita. A precedncia de operadores pode ser cancelada atravs de parnteses:

mysql> SELECT nome FROM alunos WHERE matricula > '100' AND (cidade = 'Nova Friburgo' OR codcurso='01'); Operador LIKE Busca valores alfanumricos incompletos a partir de um ou mais caracteres:

% - corresponde a uma seqncia qualquer de 0 ou mais caracteres. "_" - corresponde a qualquer caracter.

mysql> SELECT nome FROM alunos WHERE nome LIKE 'J%'; // lista todos os nomes que comecem com J

mysql> SELECT nome FROM alunos where nome LIKE '_________'; // lista todos os nomes que possuem exatamente 9 caracteres. Operador BETWEEN Busca valores entre uma faixa especificada: mysql> SELECT nome FROM alunos WHERE matricula BETWEEN '100' AND '300'; Operador IN Utiliza-se o operador IN para testar valores em uma lista especfica: mysql> SELECT nome FROM alunos WHERE codcurso IN ('01', '02');

Uso de funes
Concatenando dados sintaxe: CONCAT(campo1, campo2) mysql> SELECT matricula, nome, CONCAT(matricula, nome) FROM alunos; Arredondando valores ROUND (col/value,n) - Arredonda campo, expresso ou valor para n casas decimais, se n for omitido, as casas decimais tambm sero omitidas. Caso n seja negativo , os nmeros esquerda da vrgula sero arredondados: mysql> SELECT ROUND (90.999, 1) FROM tabela; // arredondar o valor 90,999 para 90,9 mysql> SELECT ROUND (campo, 2) FROM tabela; // arredondar o valor do campo para 2 casas decimais 0,00 Truncando valores TRUNC (col/value,n) - Trunca campo, expresso ou valor para n casas decimais, se n for omitido, todas as casas decimais sero omitidas. Caso n seja negativo, o nmero esquerda da vrgula ser truncados para zero: mysql> SELECT TRUNC (90.999, 2) FROM tabela; // arredondar o valor 90,999 para 90,99 mysql> SELECT TRUNC (campo, 1) FROM tabela; // arredondar o valor do campo para 1 casas decimais 0,0 Encontrando valores CEIL (col/value) - Encontra o menor inteiro maior ou igual a campo, expresso ou valor: mysql> SELECT CEIL(campo) FROM tabela;

// encontra o menor inteiro deste campo mysql> SELECT CEIL(99.9) FROM tabela; // encontra o menor inteiro a partir de 99.9 Raiz quadrada de um valor SQRT (col/value) - Raz do campo, expresso ou valor: mysql> SELECT SQRT(campo) FROM tabela; // encontra a raiz quadrada dos valores deste campo mysql> SELECT SQRT(81) FROM tabela; // encontra a raiz quadrada de 81 Retornando valor para comparao SIGN (col/value) - Retorna -1 se a campo, expresso ou valor um nmero negativo, retorna zero se o nmero zero e +1 se o nmero positivo: mysql> SELECT SIGN(campo) FROM tabela; OBS: uma opo interessante para se testar previamente um valor. Resto de Diviso MOD (value1,value2) - Determina o resto da diviso de value1 dividido por value2: mysql> SELECT MOD(valor1, valor2) FROM tabela; mysql> SELECT MOD(campo1, campo2) FROM tabela; OBS: uma funo que pode se tornar muito til. Soma SUM (campo) - Retorna a soma dos valores de um campo dos registros de um tabela: mysql> SELECT SUM(campo) FROM tabela; Mdia AVG (campo) - Retorna a mdia dos valores de um campo dos registros de um tabela: mysql> SELECT AVG(campo) FROM tabela; Valor Mximo MAX (campo) - Retorna o maior valor entre todos os valores de um campo dos registros de um tabela: mysql> SELECT MAX(campo) FROM tabela;

Valor Mnimo MIN (campo) - Retorna o menor valor entre todos os valores de um campo dos registros de um tabela: mysql> SELECT MIN(campo) FROM tabela; Retornando o nmero de linhas (registros) de uma tabela ou campo COUNT(*) - Retorna o nmero de linhas em uma tabela, incluindo linhas duplicadas e linhas contendo valores NULL. COUNT(campo) - Retorna o nmero de linhas no NULL no campo identificada. mysql> SELECT COUNT(*) FROM tabela; // retorna a quantidade de registros da tabela mysql> SELECT COUNT(campo) FROM tabela; // retorna a quantidade de registros no nulos deste campo mysql> SELECT COUNT(campo) FROM tabela where "condio"; // retorna a quantidade de registros do campo sobre determinada condio mysql> SELECT COUNT(DISTINCT(cidade)) FROM tabela; // retorna a quantidade de registros do campo cidade sem a duplicao de nomes

Subqueries
Uma subquery um comando SELECT inserido em uma clusula de um outro comando SQL. Pode-se desenvolver comandos sofisticados a partir de comandos simples, utilizando-se subqueries. Elas podem ser muito teis quando for necessrio selecionar linha a partir de uma tabela com uma condio que dependa de dados na prpria tabela. Sintaxe do comando SELECT campo FROM tabela WHERE expr operator (SELECT campo FROM tabela);

operator: inclui um operador de comparao como >, =, ou IN. OBS: os operadores de comparao situam-se em duas classes: operadores de linha nica (>, =, >=, <, <>, <=) e operadores de vrias linhas (IN, NOT IN). A subquery geralmente identificada como um comando aninhado SELECT, sub-SELECT, ou SELECT interno. Em geral, ela executada primeiro e seu resultado usado para completar a condio de pesquisa para a pesquisa primria ou externa. Regras Gerais

A subquery deve ser colocada entre parnteses; A subquery deve ser colocada depois de um operador de comparao. Uma clusula ORDER BY no deve ser includa em uma subquery.

Exemplo: mysql> SELECT cidade FROM alunos WHERE matricula > (SELECT matricula FROM alunos where nome='Jefferson'); // primeiro descobrir a matricula de Jefferson, depois ir exibir o nome de todas as cidades que tenham o registro matricula maior que a de Jefferson.

Segurana no acesso aos dados

Uma vez que tenha sido criado o seu banco de dados, voc dever informar ao MySQL quem ter acesso ele. O MySQL utiliza seu prprio servidor de banco de dados para implementar os acessos ao banco de dados e tabelas criadas. Ao se instalar pela primeira vez o MySQL, um banco de dados chamado 'mysql' criado. Ele contm seis tabelas:

columns_priv db func host tables_priv user

Estas tabelas so utilizadas para decidir a quem permitido fazer o que. A tabela USER contm informaes de segurana que se aplicam ao servidor como um todo. A tabela HOST d ao servidor todos os direitos da mquina. As tabelas DB, FUNC, TABLES_PRIV e COLUMNS_PRIV controlam o acesso aos bancos de dados, tabelas e colunas individuais. Vou demonstrar apenas o funcionamento das tabelas db e user, responsveis diretas pelo acesso aos bancos de dados e tabelas criadas e ao servidor como um todo. Primeiro vamos acessar o banco de dados mysql: mysql> USE mysql; Agora vamos ver seu contedo: mysql> SHOW TABLES;
+-----------------+ | Tables_in_mysql | +-----------------+ | columns_priv | | db | | func | | host | | tables_priv | | user | +-----------------+

O prximo passo ser analisar as tabelas.

A tabela user Esta tabela responsvel por definir os acessos do usurio ao servidor como um todo, ou seja, o que ele poder executar no MySQL. Vejamos a estrutura desta tabela: mysql> SHOW FIELDS FROM user;
+-----------------------+-----------------------------------+------+-----+---------+------+ | Field | Type | Null | Key | Default | Extra | +-----------------------+-----------------------------------+------+-----+---------+------+ | Host | varchar(60) binary | | PRI | | | | User | varchar(16) binary | | PRI | | | | password | varchar(16) | | | | | | Select_priv | enum('N','Y') | | | N | | | Insert_priv | enum('N','Y') | | | N | | | Update_priv | enum('N','Y') | | | N | | | Delete_priv | enum('N','Y') | | | N | | | Create_priv | enum('N','Y') | | | N | | | Drop_priv | enum('N','Y') | | | N | | | Reload_priv | enum('N','Y') | | | N | | | Shutdown_priv | enum('N','Y') | | | N | | | Process_priv | enum('N','Y') | | | N | | | File_priv | enum('N','Y') | | | N | | | Grant_priv | enum('N','Y') | | | N | | | References_priv | enum('N','Y') | | | N | | | Index_priv | enum('N','Y') | | | N | | | Alter_priv | enum('N','Y') | | | N | | | Show_db_priv | enum('N','Y') | | | N | | | Super_priv | enum('N','Y') | | | N | | | Create_tmp_table_priv | enum('N','Y') | | | N | | | Lock_tables_priv | enum('N','Y') | | | N | | | Execute_priv | enum('N','Y') | | | N | | | Repl_slave_priv | enum('N','Y') | | | N | | | Repl_client_priv | enum('N','Y') | | | N | | | ssl_type | enum('','ANY','X509','SPECIFIED') | | | | | | ssl_cipher | blob | | | | |

| x509_issuer | blob | | | | | | x509_subject | blob | | | | | | max_questions | int(11) unsigned | | | 0 | | | max_updates | int(11) unsigned | | | 0 | | | max_connections | int(11) unsigned | | | 0 | | +-----------------------+-----------------------------------+------+-----+---------+------+ 31 rows in set (0.00 sec)

OBS: como seu contedo bem grande (31 linhas) vamos analisar apenas alguns campos importantes:

Campo Host User password Select_priv Insert_priv Update_priv Delete_priv Create_priv Drop_priv Reload_priv Process_priv File_priv Grant_priv Index_priv Alter_priv

Descrio Host de origem para conexo. Usurio a obter o acesso. senha. Permisso para executar SELECTs. Permisso para executar insert. Permisso para executar update. Permisso para executar delete. Permisso para executar create. Permisso para executar drop table. Permisso para recarregar informaes via mysqladmin reload. Permisso para gerenciar processo no servidor. Permisso para ver ou gravar arquivos. Permisso para ceder seus privilgios a outros. Permisso para criar ndices. Permisso para executar alter table.

Shutdown_priv Permisso para executar shutdown no servidor.

Show_db_priv Permisso para executar show table.

Vamos ao trabalho! Exemplo 1: iremos inserir um registro de usurio "jeffestanislau" na tabela user, informando que ele pode se conectar somente do servidor local "localhost", podendo inserir, consultar, alterar e deletar dados. mysql> INSERT INTO user (Host, User, Password, Select_priv, Insert_priv, Update_priv, Delete_priv) VALUES ('localhost', 'jeffestanislau', password('vivaolinux'), 'Y', 'Y', 'Y', 'Y'); Exemplo 2: iremos inserir um registro de usurio "jefferson" na tabela user, informando que ele pode se conectar de qualquer host, podendo somente consultar e inserir dados.

mysql> INSERT INTO user (Host, User, Password, Select_priv, VALUES ('%', 'jefferson', password('estanislau'), 'Y', 'Y'); Como vimos, a tabela user no menciona banco de dados ou tabelas especficas, dando assim, acesso a todo o servidor. A tabela db Esta tabela responsvel por dar permisses para usurios acessarem banco de dados especficos, de forma a assegurar que o mesmo no acesse outros bancos de dados dentro do servidor MySQL. Vejamos a estrutura desta tabela: mysql> SHOW FIELDS FROM db;
+-----------------------+-----------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-----------------------+-----------------+------+-----+---------+-------+ | Host | char(60) binary | | PRI | | | | Db | char(64) binary | | PRI | | | | User | char(16) binary | | PRI | | | | Select_priv | enum('N','Y') | | | N | | | Insert_priv | enum('N','Y') | | | N | | | Update_priv | enum('N','Y') | | | N | | | Delete_priv | enum('N','Y') | | | N | | | Create_priv | enum('N','Y') | | | N | | | Drop_priv | enum('N','Y') | | | N | | | Grant_priv | enum('N','Y') | | | N | | | References_priv | enum('N','Y') | | | N | | | Index_priv | enum('N','Y') | | | N | | | Alter_priv | enum('N','Y') | | | N | | | Create_tmp_table_priv | enum('N','Y') | | | N | | | Lock_tables_priv | enum('N','Y') | | | N | | +-----------------------+-----------------+------+-----+---------+-------+

OBS: Novamente irei analisar apenas alguns campos importantes:

Campo Host Db User Insert_priv

Descrio Host de origem para conexo. Banco de dados selecionado. Usurio a obter acesso Permisso para executar insert.

Select_priv Permisso para executar SELECT. Update_priv Permisso para executar update. Delete_priv Permisso para executar delete. Drop_priv Index_priv Alter_priv Permisso para executar drop table. Permisso para criar ndices. Permisso para executar alter table.

A maior diferena entre a tabela db para a user realmente o campo db, onde voc especifica o banco de dados que o usurio ter acesso.

Veja o exemplo a seguir: iremos inserir um registro de usurio "jeffestanislau" na tabela db, informando que ele pode se conectar somente do servidor local localhost, tendo acesso ao banco de dados COLEGIO, podendo inserir, consultar, alterar e deletar dados. mysql> INSERT INTO db (Host, Db, User, Select_priv, Insert_priv, Update_priv, Delete_priv) VALUES ('localhost', 'COLEGIO', 'jeffestanislau', 'Y', 'Y', 'Y', 'Y'); O comando flush privileges Para que as alteraes referentes ao acesso a banco de dados e ao servidor como um todo tenham efeito, necessrio que ao final de toda rotina seja digitado o comando FLUSH PRIVILEGES, responsvel por validar as atualizaes no MySQL: mysql> FLUSH PRIVILEGES; Concluso Vimos aqui a continuao do artigo:

Gerenciando banco de dados com MySQL

e ficamos sabendo que a integridade em um banco de dados muito importante e desta forma, aprendemos algumas maneiras de assegurar isto, tambm observamos que a partir do comando Select podemos utilizar outros subcomandos, operadores e funes que resultar em uma melhor extrao de informaes armazenadas em nossos bancos de dados. Vimos que o servidor MySQL preparado para dar segurana aos seus dados e para isso necessrios que se cadastre aqueles que tem ou no direito de acessar os mesmo. Desta forma, voc passa a perceber porque o MySQL comumente utilizado pelos desenvolvedores de projetos que utilizam os servios da internet, pois estes profissionais no iriam arriscar armazenar informaes importantes em qualquer banco de dados, no mesmo? Agora voc j tem uma base razovel para desenvolver seus projetos e criar assim seus bancos de dados. At a prxima... e bom trabalho!!!! Por Jefferson Estanislau da Silva Analista de Sistemas jeffestanislau@hotmail.com

http://www.vivaolinux.com.br/artigos/verArtigo.php?codigo=581