Você está na página 1de 12

Gerenciando banco de dados com MySQL (parte 2)

Autor: Jefferson Estanislau da Silva <jeffestanislau at hotmail.com> Data: 11/01/2004

Introdução

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 começar a elaborar uma estrutura de um BD.

Nesta segunda parte, você verá opções que lhe ajudam a manter a integridade em suas tabelas, assim como mais opções para o uso da cláusula "Select" e por fim como manter a segurança no acesso ao banco de dados.

Mas vamos ao que interessa, comecem a conferir o artigo!

Restrições de integridade

São regras que servem para prevenir a entrada de informações inválidas pelos usuários. Para isso, o SGBD provê ferramentas para regras de integridade, afim de evitar a inconsistência dos dados que nele serão armazenados.

Valores nulos

Para evitar que um campo possa conter valor nulo (ou não conter valor algum) deve-se utilizar a cláusula NOT NULL após a definição da coluna, como já demonstrado anteriormente:

mysql> CREATE TABLE alunos ( -> nome VARCHAR(50) NOT NULL, -> endereco VARCHAR(50) NULL );

// não aceita valor nulo // aceita valor nulo

Valores Duplicados

Há situações onde o valor armazenado em um campo de um registro deve ser único em relação a todos os registros da tabela, para isso usamos a cláusula UNIQUE:

mysql> CREATE TABLE alunos (

-> nome VARCHAR(50) NOT NULL,

-> CPF INT(11) UNIQUE,

// não deve haver dois registro com o mesmo CPF

);

Valores Inválidos

Há situações onde o valor de um campo deve obedecer a uma regra. Para que ele fique restrito a um conjunto de valores, utiliza-se a cláusula 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 padrão para um campo acrescentando à sua definição a cláusula DEFAULT:

mysql> CREATE TABLE alunos ( -> nome VARCHAR(50) NOT NULL, -> cidade VARCHAR(30) DEFAULT "Nova Friburgo")

Campo chave ou chave primária

Como já comentado anteriormente, o campo chave é um campo muito importante para nossa tabela. Sua função é identificar univocamente uma linha do registro da tabela. Toda tabela deve possuir um campo chave. Quando este é definido, fica implícito as cláusulas UNIQUE e NOT NULL para este campo, não sendo necessário a especificação 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 responsável por fazer a exibição dos dados registrados em nossas tabelas, veremos agora como utilizar uma melhor aplicação deste recurso.

Evitando a exibição de linhas duplicadas

Para que isso não ocorra, é necessário a indicação da palavra DISTINCT imediatamente após o comando SELECT:

mysql> SELECT DISTINCT cidade FROM alunos;

Ordenando os dados

Já vimos anteriormente que para isto é necessário usar a cláusula ORDER BY. Por default está cláusula ordena os dados em ASCENDING (crescente), mas se você necessitar visualizar os dados na ordem decrescente, utilize as siglas DESC após a cláusula:

mysql> SELECT nome FROM alunos ORDER BY nome DESC;

Utilizando alias (apelidos)

Existem duas maneiras de se utilizar os Alias (apelidos) em uma cláusula do MySQL, são elas: apelido para o nome exibido no título da coluna de uma tabela e apelido para simplificar um nome de tabela que será constantemente utilizado em uma cláusula SELECT.

Exemplos 1: apelido para o título

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 cláusula:

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 são repetidos constantemente dentro desta cláusula.

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 código.

// 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 condições

Já vimos que para que se faça o uso de condições deve se usar o comando WHERE. Veremos agora várias formas de se aplicar estas condições.

NOTA: é possível utilizar operadores de comparação lógica, estes estão 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 várias linhas

AND

e

OR

ou

NOT

não

mysql> SELECT nome FROM aluno WHERE cidade='Salvador' AND matricula='300'; mysql> SELECT nome FROM aluno WHERE cidade='Salvador' OR matricula='300';

Precedência de operadores

1. Uma cláusula WHERE pode combinar vários operadores AND e OR.

2. O operador AND tem maior precedência que o operador OR.

3. Os operadores de comparação tem maior precedência que os conectivos AND e OR.

4. Todos os operadores de comparação tem a mesma precedência.

5. Operadores de igual precedência são calculados da esquerda para a direita.

6. A precedência de operadores pode ser cancelada através de parênteses:

mysql> SELECT nome FROM alunos WHERE matricula > '100' AND (cidade = 'Nova Friburgo' OR

codcurso='01');

Operador LIKE

Busca valores alfanuméricos incompletos a partir de um ou mais caracteres:

% - corresponde a uma seqüência 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 específica:

mysql> SELECT nome FROM alunos WHERE codcurso IN ('01', '02');

Uso de funções

Concatenando dados

sintaxe: CONCAT(campo1, campo2)

mysql> SELECT matricula, nome, CONCAT(matricula, nome) FROM alunos;

Arredondando valores

ROUND (col/value,n) - Arredonda campo, expressão ou valor para n casas decimais, se n for omitido, as casas decimais também serão omitidas. Caso n seja negativo , os números à esquerda da vírgula serão 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, expressão ou valor para n casas decimais, se n for omitido, todas as casas decimais serão omitidas. Caso n seja negativo, o número à esquerda da vírgula 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, expressão 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) - Raíz do campo, expressão 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 comparação

SIGN (col/value) - Retorna -1 se a campo, expressão ou valor é um número negativo, retorna zero se o número é zero e +1 se o número é positivo:

mysql> SELECT SIGN(campo) FROM tabela;

OBS: É uma opção interessante para se testar previamente um valor.

Resto de Divisão

MOD (value1,value2) - Determina o resto da divisão de value1 dividido por value2:

mysql> SELECT MOD(valor1, valor2) FROM tabela; mysql> SELECT MOD(campo1, campo2) FROM tabela;

OBS: É uma função 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;

Média

AVG (campo) - Retorna a média dos valores de um campo dos registros de um tabela:

mysql> SELECT AVG(campo) FROM tabela;

Valor Máximo

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 Mínimo

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 número de linhas (registros) de uma tabela ou campo

COUNT(*) - Retorna o número de linhas em uma tabela, incluindo linhas duplicadas e linhas contendo valores NULL.

COUNT(campo) - Retorna o número de linhas não 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 não nulos deste campo

mysql> SELECT COUNT(campo) FROM tabela where "condição"; // retorna a quantidade de registros do campo sobre determinada condição

mysql> SELECT COUNT(DISTINCT(cidade)) FROM tabela; // retorna a quantidade de registros do campo cidade sem a duplicação de nomes

Subqueries

Uma subquery é um comando SELECT inserido em uma cláusula 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 necessário selecionar linha a partir de uma tabela com uma condição que dependa de dados na própria tabela.

Sintaxe do comando

SELECT campo FROM tabela

WHERE expr operator

(SELECT campo FROM tabela);

operator: inclui um operador de comparação como >, =, ou IN.

OBS: os operadores de comparação situam-se em duas classes: operadores de linha única (>, =, >=, <, <>, <=) e operadores de várias 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 condição de pesquisa para a pesquisa primária ou externa.

Regras Gerais

A subquery deve ser colocada entre parênteses;

A subquery deve ser colocada depois de um operador de comparação.

Uma cláusula ORDER BY não deve ser incluída 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.

Segurança 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 próprio 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 contém seis tabelas:

columns_priv

db

func

host

tables_priv

user

Estas tabelas são utilizadas para decidir a quem é permitido fazer o que.

A tabela USER contém informações de segurança que se aplicam ao servidor como um todo. A tabela HOST dá ao servidor todos os direitos da máquina. 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, responsáveis 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 conteúdo:

mysql> SHOW TABLES;

+-----------------+

| Tables_in_mysql |

+-----------------+

|

columns_priv

|

|

db

|

|

func

|

| host

|

| tables_priv

|

| user

|

+-----------------+

O próximo passo será analisar as tabelas.

A tabela user

Esta tabela é responsável por definir os acessos do usuário 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 conteúdo é bem grande (31 linhas) vamos analisar apenas alguns campos importantes:

Campo

Descrição

Host

Host de origem para conexão.

User

Usuário a obter o acesso.

password

senha.

Select_priv

Permissão para executar SELECTs.

Insert_priv

Permissão para executar insert.

Update_priv

Permissão para executar update.

Delete_priv

Permissão para executar delete.

Create_priv

Permissão para executar create.

Drop_priv

Permissão para executar drop table.

Reload_priv

Permissão para recarregar informações via mysqladmin reload.

Shutdown_priv Permissão para executar shutdown no servidor.

Process_priv

Permissão para gerenciar processo no servidor.

File_priv

Permissão para ver ou gravar arquivos.

Grant_priv

Permissão para ceder seus privilégios a outros.

Index_priv

Permissão para criar índices.

Alter_priv

Permissão para executar alter table.

Show_db_priv

Permissão para executar show table.

Vamos ao trabalho!

Exemplo 1: iremos inserir um registro de usuário "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 usuário "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 não menciona banco de dados ou tabelas específicas, dando assim, acesso a todo o servidor.

A tabela db

Esta tabela é responsável por dar permissões para usuários acessarem banco de dados específicos, de forma a assegurar que o mesmo não 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

Descrição

Host

Host de origem para conexão.

Db

Banco de dados selecionado.

User

Usuário a obter acesso

Select_priv

Permissão para executar SELECT.

Insert_priv

Permissão para executar insert.

Update_priv Permissão para executar update.

Delete_priv

Permissão para executar delete.

Drop_priv

Permissão para executar drop table.

Index_priv

Permissão para criar índices.

Alter_priv

Permissão para executar alter table.

A maior diferença entre a tabela db para a user é realmente o campo db, onde você especifica o banco de dados que o usuário terá acesso.

Veja o exemplo a seguir: iremos inserir um registro de usuário "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 alterações referentes ao acesso a banco de dados e ao servidor como um todo tenham efeito, é necessário que ao final de toda rotina seja digitado o comando FLUSH PRIVILEGES, responsável por validar as atualizações no MySQL:

mysql> FLUSH PRIVILEGES;

Conclusão

Vimos aqui a continuação 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, também observamos que a partir do comando Select podemos utilizar outros subcomandos, operadores e funções que resultará em uma melhor extração de informações armazenadas em nossos bancos de dados.

Vimos que o servidor MySQL é preparado para dar segurança aos seus dados e para isso é necessários que se cadastre aqueles que tem ou não direito de acessar os mesmo.

Desta forma, você passa a perceber porque o MySQL é comumente utilizado pelos desenvolvedores de projetos que utilizam os serviços da internet, pois estes profissionais não iriam arriscar armazenar informações importantes em qualquer banco de dados, não é mesmo?

Agora você já tem uma base razoável para desenvolver seus projetos e criar assim seus bancos de dados.

Até a próxima

e bom trabalho!!!!

Por Jefferson Estanislau da Silva Analista de Sistemas jeffestanislau@hotmail.com

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