Docstoc

PHP_MySQL_Apache_Linux

Document Sample
PHP_MySQL_Apache_Linux Powered By Docstoc
					ETE Pedro Ferreira Alves

Apostila

Gerenciamento de Banco de Dados com MySQL Servidor WEB APACHE PHP
Adaptado por Maromo Professor Marcos Roberto de Moraes

MySQL + APACHE + PHP

Índice
1. 2. INTRODUÇÃO ____________________________________________________________________ 4 GERENCIAMENTO DE BANCO DE DADOS COM MYSQL (PARTE I)___________________ 5

2.1. SISTEMA DE BANCO DE DADOS_______________________________________________________ 5 2.2. BANCO DE DADOS _________________________________________________________________ 5 2.3. CARACTERÍSTICAS DOS SGBDS______________________________________________________ 5 2.4. CLASSES DE USUÁRIOS _____________________________________________________________ 5 2.5. A LINGUAGEM SQL E SEUS COMPONENTES ____________________________________________ 5 2.5.1. DDL (DATA DEFINITION LANGUAGE) ________________________________________________ 5 2.5.2. DML (DATA MANIPULATION LANGUAGE) _____________________________________________ 6 2.5.3. SINTAXE DE UM COMANDO SQL _____________________________________________________ 6 2.6. SOBRE O MYSQL _________________________________________________________________ 6 2.6.1. OBTENDO O MYSQL ______________________________________________________________ 6 2.6.2. UTILIZANDO O MYSQL____________________________________________________________ 7 2.6.3. MAS O QUE É CAMPO CHAVE? ______________________________________________________ 9 2.6.4. CRIANDO A BASE DE DADOS ________________________________________________________ 9 2.6.5. ALTERANDO A BASE DE DADOS _____________________________________________________ 11 2.6.6. VISUALIZANDO A ESTRUTURA DE NOSSA BASE DE DADOS ________________________________ 11 2.6.7. MAS SÓ PARA SER DO CONTRA, VAMOS SIMULAR UM PROBLEMA __________________________ 12 2.6.8. MANIPULANDO DADOS NAS TABELAS ________________________________________________ 13 2.6.9. INSERINDO DADOS ______________________________________________________________ 13 2.6.10. VISUALIZANDO DADOS __________________________________________________________ 14 2.6.11. VISUALIZANDO DADOS DE VÁRIAS TABELAS _________________________________________ 15 2.6.12. ALTERANDO DADOS ____________________________________________________________ 16 2.6.13. APAGANDO DADOS _____________________________________________________________ 17 2.6.14. CONCLUSÃO DO AUTOR __________________________________________________________ 17 3. GERENCIAMENTO DE BANCO DE DADOS COM MYSQL (PARTE II) _________________ 19

3.1. INTRODUÇÃO ____________________________________________________________________ 19 3.2. RESTRIÇÕES DE INTEGRIDADE______________________________________________________ 19 3.2.1. VALORES NULOS ________________________________________________________________ 19 3.2.2. VALORES DUPLICADOS ___________________________________________________________ 19 3.2.3. VALORES INVÁLIDOS ____________________________________________________________ 19 3.2.4. VALORES DEFAULT ______________________________________________________________ 20 3.2.5. CAMPO CHAVE OU CHAVE PRIMÁRIA ________________________________________________ 20 3.3. VISUALIZANDO DADOS DE MANEIRA MAIS ORGANIZADA_________________________________ 20 3.3.1. EVITANDO A EXIBIÇÃO DE LINHAS DUPLICADAS _______________________________________ 20 3.3.2. ORDENANDO OS DADOS __________________________________________________________ 20 3.3.3. UTILIZANDO ALIAS (APELIDOS)_____________________________________________________ 20 3.3.4. UTILIZANDO CONDIÇÕES __________________________________________________________ 22 3.3.5. OPERADOR LIKE________________________________________________________________ 22 3.3.6. OPERADOR BETWEEN___________________________________________________________ 23 3.3.7. OPERADOR IN __________________________________________________________________ 23 3.3.8. CONCATENANDO DADOS __________________________________________________________ 23 3.3.9. ARREDONDANDO VALORES ________________________________________________________ 23

2/50

MySQL + APACHE + PHP
3.3.10. TRUNCANDO VALORES __________________________________________________________ 23 3.3.11. ENCONTRANDO VALORES ________________________________________________________ 24 3.3.12. RAIZ QUADRADA DE UM VALOR ___________________________________________________ 24 3.3.13. RETORNANDO VALOR PARA COMPARAÇÃO __________________________________________ 24 3.3.14. RESTO DE DIVISÃO _____________________________________________________________ 24 3.3.15. SOMA ________________________________________________________________________ 25 3.3.16. MÉDIA _______________________________________________________________________ 25 3.3.17. VALOR MÁXIMO _______________________________________________________________ 25 3.3.18. VALOR MÍNIMO ________________________________________________________________ 25 3.3.19. RETORNANDO O NÚMERO DE LINHAS (REGISTROS) DE UMA TABELA OU CAMPO ______________ 25 3.4. SUBQUERIES ____________________________________________________________________ 26 3.5. SEGURANÇA NO ACESSO AOS DADOS _________________________________________________ 26 3.5.1. A TABELA USER _________________________________________________________________ 27 3.5.2. A TABELA DB ___________________________________________________________________ 29 3.5.3. O COMANDO FLUSH PRIVILEGES ____________________________________________________ 30 3.6. CONCLUSÃO ____________________________________________________________________ 30 4. 5. COMPILANDO O APACHE 2 COM PHP E MYSQL___________________________________ 32 IMPLEMENTANDO SCRIPTS PHP COM MYSQL____________________________________ 36 INTRODUÇÃO ____________________________________________________________________ 36 O QUE É PHP?___________________________________________________________________ 36 CRIANDO UMA APLICAÇÃO ________________________________________________________ 36 TIPOS DE DADOS ________________________________________________________________ 38 USO DE FUNÇÃO ________________________________________________________________ 39 CRIANDO UM BANCO DE DADOS PARA USO EM NOSSOS SCRIPTS ___________________________ 41 FAZENDO O PHP SE COMUNICAR COM O MYSQL ______________________________________ 43 CRIANDO OS HTMLS DE INTERAÇÃO COM O USUÁRIO __________________________________ 47 CONCLUSÃO ____________________________________________________________________ 50

5.1. 5.2. 5.2.1. 5.2.2. 5.2.3. 5.3. 5.4. 5.5. 5.6.

3/50

MySQL + APACHE + PHP

1. Introdução

Caros alunos, este material é uma compilação de artigos escritos para o Viva o Linux, que considero muito importante para o aprendizado de Banco de Dados e Integração PHP / Apache e MySQL. Fiz algumas adaptações para a seqüência das aulas, mas respeitei os originais dos colaboradores do Viva o Linux. Abaixo: • • Jefferson Estanislau da Silva Thiago Alves

Todos os artigos utilizados nesse material estão publicados no site www.vivaolinux.com.br e são de autoria dos colaboradores citados. Espero que possamos aproveitar ao máximo esse material e nossas aulas.

Abraços

Maromo Prof. Marcos Roberto de Moraes professormoraes@gmail.com

4/50

MySQL + APACHE + PHP

2. Gerenciamento de Banco de Dados com MySQL (Parte I)
2.1. Sistema de banco de Dados
Um sistema de banco de dados é um ambiente de hardware e de software, composto por dados armazenados em um banco de dados (BD), o software de gerência do banco de dados (SGBD) e os programas de aplicação.

2.2. Banco de Dados
São conjuntos de dados (versáteis, compartilháveis e integrados) armazenados em computador.

2.3. Características dos SGBDs
Os SGBDs não são caracterizados tão-somente pelos seus modelos de banco de dados, um SGBD também é caracterizado por suas funções, que implementam um conjunto básico de facilidades e serviços que definem a capacidade de banco de dados que um sistema deve possuir para ser considerado um banco de dados. Um SGBD deve também prover mecanismos de segurança de acesso para consulta ou atualização dos objetos persistentes. Em geral, estes mecanismos são implementados por meio de comandos de concessão/revogação de privilégios de acesso a usuários individuais ou grupos de usuários. Dependendo da aplicação, o nível de segurança pode ser de coleções de dados (tabelas e registros ou linhas) , atributos isolados (campos ou colunas) e até mesmo de conteúdo (valores de dados). Um banco de dados deve estar sempre num estado consistente, satisfazendo permanentemente algumas condições de consistência, chamadas restrições de integridade. O SGBD tem a incumbência de garantir a integridade do banco de dados na passagem de um estado para outro, que ocorre ao final de cada transação.

2.4. Classes de usuários
Um sistema de banco de dados faz parte de um sistema mais amplo, conhecido como sistema de informação, cujos componentes, além da tecnologia, são a organização ou empresa e os recursos humanos. Os componentes humanos podem ser classificados em três grandes classes de usuários do banco de dados:
• • •

Administradores; Desenvolvedores; Usuários Finais.

2.5. A Linguagem SQL e seus componentes 2.5.1. DDL (Data Definition Language)

A SQL DDL fornece comandos para definição e modificação de esquemas de relação, remoção de relações e criação de índices. Os principais comandos que fazem parte da DDL são:
• • •

CREATE; ALTER; DROP. 5/50

MySQL + APACHE + PHP

2.5.2.

DML (Data Manipulation Language)

A SQL DML inclui uma linguagem de consulta baseada na álgebra relacional e no cálculo relacional. Compreende também comandos para inserir, remover e modificar informações em um banco de dados. Os comandos básicos da DML são:
• • • •

SELECT; INSERT; UPDATE; DELETE.

OBS: Há outros componentes, mas estes não serão relevantes neste artigo e desta forma, não serão abordados.

2.5.3.

Sintaxe de um comando SQL

Um comando SQL é composto de cláusulas, algumas opcionais e outras obrigatórias. Para maior inteligibilidade, é conveniente iniciar uma cláusula em uma nova linha, mas isso não é obrigatório. As palavras que compõem um comando devem ser separadas por espaços ou tabs e o comando para ser executado deve terminar com ";" (ponto e vírgula). Por exemplo: SELECT * FROM ALUNOS;

2.6. Sobre o MySQL
O banco de dados MySQL é um sério competidor para os maiores sistemas de banco de dados existentes para aplicações de pequeno e médio porte. Uma das grandes vantagens do MySQL é suportar mais de uma dúzia de tipos de dados. Desta forma, o MySQL é altamente recomendado para aqueles que irão desenvolver aplicações de pequeno e médio porte e querem bons resultados a um custo reduzido.

2.6.1.

Obtendo o MySQL

Nas distribuições Linux do mercado, os CDs possuem o pacote MySQL, desta forma, durante a instalação do sistema, você pode marcar o pacote mysql para ser instalado ou se ainda não o fez, pode abrir o seu gerenciador de pacotes e instalá-lo a partir do cd. Se você quer ter nas mão a versão mais atual deste BD, acesse o site do desenvolvedor em http://www.mysql.com e baixe o arquivo mysql-x.xx.xx.tar.gz para o diretório /usr/src. Lembre-se que você deve estar como root e que o "xx" é o número da versão.

6/50

MySQL + APACHE + PHP Para descompactar o MySQL use: # tar -xvzf mysql-x.xx.xx.tar.gz Após descompactar o arquivo, você irá entrar no diretório que foi criado e iniciar o processo de instalação desta forma. # cd mysql-x.xx.xx # ./configure # make # make install Agora devemos criar a estrutura do banco de dados e suas tabelas administrativas. Ainda estando dentro do diretório do mysql, faça desta forma: # ./scripts/mysql_install_db Inicialmente ele é setado para ser utilizado sem senha, bastando apenas digitar mysql num terminal para acessar o programa, mas é aconselhável que você coloque uma senha de acesso, assim você preserva integridade na questão de segurança. Estando no diretório do mysql, faça desta forma: # ./bin/mysqladmin -u root password senha Onde senha é a palavra ou dígitos que você quer usar como sua senha para o MySQL e não a senha do root no Linux. Agora que já definimos uma senha para ele, vamos inicializar o MySQL para que assim possamos começar a brincar... # ./bin/safe_mysql & O mysql está pronto para ser utilizado.

2.6.2.

Utilizando o MySQL

Para utilizarmos o MySQL, devemos digitar o comando mysql -p, em seguida será solicitado a senha e após pressionar o Enter, se esta estiver correta, você irá ver o prompt do MySQL, desta forma: # mysql -p Enter password: Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 3 to server version: 4.0.11a-gamma Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql> 7/50

MySQL + APACHE + PHP OBS: Se você desejar encerrar as atividades do MySQL, basta usar o comando EXIT para fechá-lo. Agora que o MySQL está carregado, poderemos começar a criar nossa base de dados, mas antes, vamos conhecer os tipos de dados suportados para elaborar nossas tabelas. Tipo INT REAL CHAR(tamanho) TEXT(tamanho) Descrição Valor inteiro Valor de ponto flutuante Valor de caractere de tamanho fixo. Valor inferior ao definido será deixado em branco. Valor de caractere de tamanho variável.

VARCHAR(tamanh Valor de caractere de tamanho variável. Valores inferiores ao definido o) serão suprimidos. DATE TIME DATETIME Valor para datas do tipo (AAAA-MM-DD) Valor de tempo padrão Valor para data e hora agregados.

Veremos agora como é a sintaxe para se criar uma tabela: CREATE TABLE nome_tabela ( campo1 tipo(tamanho) null/not null, campo2 tipo(tamanho) null/not null, campo3 tipo(tamanho) null/not null, PRIMARY KEY (campo)); Esclarecendo as informações da sintaxe acima: CREATE TABLE comando para se criar uma tabela nome_tabela campo1..3 tipo tamanho null/not null o nome que você dará a esta tabela nome do campo dentro da tabela tipo de dado para este campo da tabela tamanho para ser digitados os dados do tipo escolhido deve-se escolher um dos dois para indicar se o campo aceita valores nulos ou não nome do campo que será o campo chave da tabela

PRIMARY KEY comando que informará qual é o campo chave na tabela campo

Agora que você sabe os tipos de dados suportados e a sintaxe de como criar uma tabela, é fundamental que você saiba o que deseja criar, isto é, como será a sua base de dados e como todo bom analista de sistemas elabora uma documentação de projeto antes de meter a mão na massa, vamos a cola do nosso modelo da base de dados.

8/50

MySQL + APACHE + PHP Iremos desenhar o modelo para a criação de uma base de dados simples, que seria o início do controle das informações de um colégio. Nossa base de dados será chamada de COLEGIO e nela teremos as tabelas ALUNOS, CURSOS e DISCIPLINAS. Vamos então ao modelo. Tabela ALUNOS: Nome do campo Tipo de dado matricula nome endereco cidade codcurso Varchar(5) * Varchar(50) Varchar(50) Varchar(30) char(2)

Obs: O * asterisco, significa que o campo é chave. Tabela CURSOS: Nome do campo Tipo de dado codcurso nomecurso coddisc1 coddisc2 coddisc3 char(2) * Varchar(50) char(2) char(2) char(2)

Tabela DISCIPLINAS: Nome do campo Tipo de dado coddisciplina nomedisciplina char(2) * Varchar(30)

2.6.3.

Mas o que é Campo Chave?

Campo chave é o campo mais importante de nossa tabela, pois este é o campo que irá identificar a posição de todos os outros dados de um registro. Os dados deste campo são exclusivos, isto é, não poderá existir dois registros deste campo em sua tabela com o mesmo valor. Por isso, toda tabela deve ter um campo designado como chave primária para o controle dos registros.

2.6.4.

Criando a base de dados

9/50

MySQL + APACHE + PHP Para podermos criar a base de dados a partir de nosso modelo, observe a sintaxe a seguir: CREATE DATABASE nome_base_de_dados; Esclarecendo as informações da sintaxe a cima: CREATE DATABASE Comando para se criar uma base de dados o nome que você dará a sua base de nome_base_de_dados dados

Agora vamos meter a mão na massa. Lembre-se que o ";" (ponto e vírgula) serve para encerrar a linha de comando e após ele, deve-se pressionar "Enter" para que o comando seja executado. O texto que será apresentado abaixo da linha de comando é a confirmação de que o comando foi executado com êxito, neste nosso caso. A partir do prompt do MySQL, digite o comando abaixo: mysql> create database COLEGIO; Query OK, 1 row affected (0.29 sec) // Isto indica que sua base foi criada. Para utilizar agora esta base de dados, use o comando abaixo: mysql> use COLEGIO; Database changed // Isto indica que sua base está em uso. Agora que já criamos a base de dados e ela está em uso, poderemos criar as nossas tabelas. Criando a tabela Alunos: mysql> create table ALUNOS ( -> matricula varchar(5) not null, -> nome varchar(50) not null, -> endereco varchar(50) null, -> cidade varchar(30) null, -> primary key(matricula) ); Query OK, 0 rows affected (0.21 sec) Criando a tabela Cursos: mysql> create table CURSOS ( -> codcurso char(2) not null, -> nomecurso varchar(30) not null, -> coddisc1 char(2) not null, -> coddisc2 char(2) not null, -> coddisc3 char(2) not null, -> primary key(codcurso) ); Query OK, 0 rows affected (0.00 sec) Criando a tabela Disciplinas: mysql> create table DISCIPLINAS ( -> coddisciplina char(2) not null, -> nomedisciplina varchar(30) not null, 10/50

MySQL + APACHE + PHP -> primary key(coddisciplina) ); Query OK, 0 rows affected (0.00 sec) Muito bem! Todas as tabelas foram criadas com sucesso.

2.6.5.

Alterando a base de dados

Observe que houve erros durante a digitação, pois esquecemos o campo codcurso na tabela Alunos e trocamos o valor de 50 para 30 do tipo varchar do campo nomecurso da tabela Cursos. Para corrigirmos isso, iremos utilizar o comando ALTER TABLE e usar os parâmetros ADD e CHANGE. Adicionando o campo "codcurso" na tabela Alunos: mysql> alter table ALUNOS -> add codcurso char(2) not null; Query OK, 0 rows affected (0.00 sec) Records: 0 Duplicates: 0 Warnings: 0 Alterando o tamanho do campo "nomecurso" na tabela Cursos: mysql> alter table CURSOS -> change nomecurso nomecurso varchar(50); Query OK, 0 rows affected (0.00 sec) Records: 0 Duplicates: 0 Warnings: 0 Muito bem! Agora nossas tabelas estão de acordo com o modelo proposto.

2.6.6.

Visualizando a estrutura de nossa base de dados

Veremos agora como ficou a estrutura de nossa base de dados. Digite o comando a seguir para saber quais são as tabelas da base de dados COLEGIO: mysql> show tables; +-------------------+ | Tables_in_COLEGIO | +-------------------+ | ALUNOS | | CURSOS | | DISCIPLINAS | +-------------------+ 3 rows in set (0.00 sec) OBS: Como já estávamos com a base de dados COLEGIO em uso, não foi preciso especificar seu nome.

11/50

MySQL + APACHE + PHP Agora vamos ver como estão nossas tabelas, digite o comando abaixo: mysql> show fields from ALUNOS; +-----------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-----------+-------------+------+-----+---------+-------+ | matricula | varchar(5) | | PRI | | | | nome | varchar(50) | | | | | | endereco | varchar(50) | YES | | NULL | | | cidade | varchar(30) | YES | | NULL | | | codcurso | char(2) | | | | | +-----------+-------------+------+-----+---------+-------+ 5 rows in set (0.00 sec) mysql> show fields from CURSOS; +-----------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-----------+-------------+------+-----+---------+-------+ | codcurso | char(2) | | PRI | | | | nomecurso | varchar(50) | YES | | NULL | | | coddisc1 | char(2) | | | | | | coddisc2 | char(2) | | | | | | coddisc3 | char(2) | | | | | +-----------+-------------+------+-----+---------+-------+ 5 rows in set (0.00 sec) mysql> show fields from DISCIPLINAS; +----------------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +----------------+-------------+------+-----+---------+-------+ | coddisciplina | char(2) | | PRI | | | | nomedisciplina | varchar(30) | | | | | +----------------+-------------+------+-----+---------+-------+ 2 rows in set (0.00 sec) E aí, fez a comparação entre o modelo e o resultado da estrutura da criação de nossas tabelas? Se fez, você constatou que elas são equivalentes e o nosso trabalho está perfeito!

2.6.7.

Mas só para ser do contra, vamos simular um problema

Digamos que o analista (oh, este analista não sou eu não tá, hehehe!!), cometeu um erro no projeto e especificou um campo há mais na tabela CURSOS, pois deveria ter apenas 2 "coddisc" e ele acabou especificando 3. Devemos então apagar este campo, para isto use o comando abaixo: mysql> alter table CURSOS -> drop coddisc3; Query OK, 0 rows affected (0.00 sec) Records: 0 Duplicates: 0 Warnings: 0 Como visto acima, o parâmetro DROP é utilizado para apagar um campo dentro de uma tabela. Use 12/50

MySQL + APACHE + PHP o comando show fields from CURSOS; para ver novamente a estrutura da tabela.

2.6.8.

Manipulando dados nas tabelas

Agora que já temos a nossa estrutura de tabelas prontas, é hora de começar a inserir dados nelas, pois é para isso que elas servem, armazenar dados para que estes sejam trabalhados mais tarde.

2.6.9.

Inserindo Dados

O comando utilizado para inserir dados nas tabelas é o INSERT, veja a sintaxe abaixo para se usar este comando: INSERT INTO tabela VALUES (valor_campo1, valor_campo2, ..., valorcampoN); OBS: Insere valores na ordem correta de todos os campos da tabela. Vamos agora para a inserção de dados. Iremos começar com a tabela DISCIPLINAS, sendo assim, a partir do prompt do MySQL, digite os comandos abaixo: mysql> insert into DISCIPLINAS values ('10','Matematica'); Query OK, 1 row affected (0.30 sec) mysql> insert into DISCIPLINAS values ('20','Portugues'); Query OK, 1 row affected (0.00 sec) mysql> insert into DISCIPLINAS values ('30','Quimica'); Query OK, 1 row affected (0.00 sec) mysql> insert into DISCIPLINAS values ('40','Biologia'); Query OK, 1 row affected (0.00 sec) OBS: O uso de aspas simples é obrigatório por se tratar de um valor não numérico. Lembre-se que '10' foi para o campo "coddisciplina" e que 'Matematica' foi para o campo "nomedisciplina", de acordo com a ordem dos campos da tabela. Vamos agora para a tabela CURSOS: mysql> insert into CURSOS values ('01', 'Ensino Medio', '30', '40'); Query OK, 1 row affected (0.00 sec) mysql> insert into CURSOS values ('02', 'Ensino Fundamental', '10', '20'); Query OK, 1 row affected (0.00 sec) OBS: Lembre-se que '01' foi para o campo "codcurso", 'Ensino Medio' para "nomecurso", '30' para "coddisc1" e '40' para "coddisc2". Vamos agora para a tabela ALUNOS: mysql> insert into ALUNOS values ('100', 'Jefferson Estanislau da Silva', 'Rua Alberto Braune - 150', 'Nova Friburgo', '01'); Query OK, 1 row affected (0.00 sec) 13/50

MySQL + APACHE + PHP mysql> insert into ALUNOS values ('200', 'Leila Maria Muniz da Silva', 'Rua General Osorio - 90', 'Nova Friburgo', '01'); Query OK, 1 row affected (0.00 sec) mysql> insert into ALUNOS values ('300', 'Camila Silva Perez', 'Rua Barata Ribeiro - 570', 'Rio de Janeiro', '02'); Query OK, 1 row affected (0.00 sec) mysql> insert into ALUNOS values ('400', 'Victor Estanislau da Silva', 'Rua Galdino do Valle - 200', 'Nova Friburgo', '02'); Query OK, 1 row affected (0.00 sec) OBS: Lembre-se que '100' foi para o campo "matricula", 'Jefferson Estanislau da Silva' foi para "nome", 'Rua Alberto...' para "endereco", 'Nova...' para "cidade" e '01' para "codcurso". Muito bem! Acabamos de inserir dados em nossa base de dados. Mas e agora?

2.6.10.

Visualizando dados

Não iria fazer sentido você armazenar dados se não pudesse visualizá-los quando fosse preciso, correto? Por isso, iremos aprender agora como visualizar estes dados. O comando a ser utilizado é o SELECT, veja a sintaxe dele abaixo: SELECT {campo(s)} FROM {tabela(s)} WHERE {condição} ORDER BY {campo(s)} GROUP BY {campo(s)} Esclarecendo as informações da sintaxe a cima: SELECT campo(s) FROM tabela(s) WHERE condição ORDER BY GROUP BY comando para se chamar a visualização de registros campos da tabela, para referência da visualização dos registros chamada para indicar a tabela tabela ou tabelas a serem utilizadas chamada para uma condição condição que deve ser verdadeira para que os registro sejam visualizados permite ordenar a visualização de registros em função de um campo especifico permite agrupar a visualização de registros em função de um campo especifico

Obs: O "*" (asterisco), terá um papel importante neste comando. Exemplo1: Visualizar os nomes da tabela alunos quando a matricula for igual a '100'. 14/50

MySQL + APACHE + PHP mysql> select nome from ALUNOS -> where matricula='100'; +-------------------------------+ | nome | +-------------------------------+ | Jefferson Estanislau da Silva | +-------------------------------+ 1 row in set (0.46 sec) Exemplo2: Visualizar os nomes da tabela alunos quando a codcurso for igual a '01'. mysql> select nome from ALUNOS -> where codcurso='01'; +-------------------------------+ | nome | +-------------------------------+ | Jefferson Estanislau da Silva | | Leila Maria Muniz da Silva | +-------------------------------+ 2 rows in set (0.00 sec) Exemplo3: Visualizar os nomes e endereço da tabela alunos quando a cidade for igual a 'Nova Friburgo'. mysql> select nome, endereco from ALUNOS -> where cidade='Nova Friburgo'; +-------------------------------+----------------------------+ | nome | endereco | +-------------------------------+----------------------------+ | Jefferson Estanislau da Silva | Rua Alberto Braune - 150 | | Leila Maria Muniz da Silva | Rua General Osorio - 90 | | Victor Estanislau da Silva | Rua Galdino do Valle - 200 | +-------------------------------+----------------------------+ 3 rows in set (0.00 sec) Exemplo4: Visualizar todos os campos da tabela alunos. mysql> select * from ALUNOS; ... Exemplo5: Visualizar todos os campos da tabela alunos, ordenando-os pelo campo nome. mysql> select * from ALUNOS -> order by nome; ...

2.6.11.

Visualizando dados de várias tabelas

Para que isto ocorra, será fundamental o campo chave, que ajudará a fazer a ligação com um campo comum de outra tabela, mas que tem o mesmo tipo de dado. Veja a sintaxe a seguir: select TABELA1.campo, TABELA2.campo from TABELAS where TABELA1.campo_chave = TABELA2.campo_comum and TABELA.campo = valor;

15/50

MySQL + APACHE + PHP Esclarecendo as informações da sintaxe a cima: tabela1.campo tabela2.campo tabelas tabela1.campo_chave campo a ser exibido campo a ser exibido nome das tabelas a serem usadas campo chave para junção qualquer uma das tabelas indicadas valor para referência da condição

tabela2.campo_comum campo comum para junção tabela.campo valor

Exemplo6: Visualizar o campo "nome" da tabela alunos e o campo "nomecurso" da tabela cursos, retirado das tabelas alunos e cursos, quando codcurso da tabela alunos for igual a codcurso da tabela cursos e a cidade da tabela alunos seja igual a 'Nova Friburgo'. mysql> select ALUNOS.nome, CURSOS.nomecurso from ALUNOS, CURSOS -> where ALUNOS.codcurso = CURSOS.codcurso -> and ALUNOS.cidade='Nova Friburgo'; +-------------------------------+--------------------+ | nome | nomecurso | +-------------------------------+--------------------+ | Jefferson Estanislau da Silva | Ensino Medio | | Leila Maria Muniz da Silva | Ensino Medio | | Victor Estanislau da Silva | Ensino Fundamental | +-------------------------------+--------------------+ 3 rows in set (0.35 sec)

2.6.12.

Alterando dados

Outra coisa importante é você poder alterar uma informação, quando visualizado que esta foi cadastrada erroneamente, para isso iremos utilizar o comando UPDATE, como mostra a sintaxe abaixo: UPDATE tabela SET campo = valor WHERE {condição}; Vamos a uma explicação prática desta sintaxe: mysql> update ALUNOS -> set cidade='Salvador' -> where matricula='300'; Query OK, 1 row affected (0.00 sec) Rows matched: 1 Changed: 1 Warnings: 0 O exemplo acima significou que: usando a tabela alunos, altere a cidade para 'Salvador' quando a matricula for igual a '300'.

16/50

MySQL + APACHE + PHP Para ver a alteração, use o comando: select * from ALUNOS; Neste próximo exemplo, usando a tabela alunos, iremos mudar o nome para 'Joao Vieira da Silva' quando a cidade for igual a 'Salvador'. mysql> update ALUNOS -> set nome='Joao Vieira da Silva' -> where cidade='Salvador'; Query OK, 1 row affected (0.00 sec) Rows matched: 1 Changed: 1 Warnings: 0 Para ver a alteração, use o comando: select * from ALUNOS;

2.6.13.

Apagando dados

Como toda a informação pode se tornar inútil ou desnecessária, devemos aprender como apagar um dado de nossa tabela. Para isso, iremos utilizar o comando DELETE, veja a sintaxe a seguir: DELETE FROM tabela WHERE {condição}; Vamos a uma explicação prática desta sintaxe: mysql> delete from ALUNOS -> where matricula='300'; Query OK, 1 row affected (0.41 sec) Observe que usei para esta condição o número da matrícula, mas poderia ter usado o valor de qualquer campo.

2.6.14.

Conclusão do autor

Vimos aqui o que é um banco de dados e alguns de seus conceitos sobre a linguagem SQL e como exemplo utilizamos o MySQL para criar uma base de dados e praticar alguns comandos. Foi possível perceber que utilização do SQL é extremamente simples e o uso do MySQL é um fator economicamente louvável, pois para que pagar um valor absurdo se temos este eficiente BD perfeitamente adequado para transações via internet com o uso do PHP, desktop através do C++ ou Kylix, Gambas. Neste primeiro artigo, apresentei apenas os comandos básicos, função iniciais para que você possa ir se acostumando com seu uso. No próximo artigo, irei apresentar novos comandos e uma maneira de deixar seu BD seguro. Espero que tenham gostado e que este artigo seja útil para muitos! Por Jefferson Estanislau da Silva Analista de Sistemas 17/50

MySQL + APACHE + PHP jeffestanislau@hotmail.com

18/50

MySQL + APACHE + PHP

3. Gerenciamento de Banco de Dados com MySQL (Parte II)
3.1. Introdução
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.

3.2. 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.

3.2.1.

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, // não aceita valor nulo -> endereco VARCHAR(50) NULL // aceita valor nulo );

3.2.2.

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 ... );

3.2.3.

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 ... ); 19/50

MySQL + APACHE + PHP

3.2.4.

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") ...

3.2.5.

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

3.3. 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.

3.3.1.

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;

3.3.2.

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;

3.3.3.

Utilizando alias (apelidos)

Existem duas maneiras de se utilizar os Alias (apelidos) em uma cláusula do MySQL, são elas: 20/50

MySQL + APACHE + PHP 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 substituído 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 | +-------------------------------+--------------------+

21/50

MySQL + APACHE + PHP
| Jefferson Estanislau da Silva | Ensino Medio | | Leila Maria Muniz da Silva | Ensino Medio | | Victor Estanislau da Silva | Ensino Fundamental | +-------------------------------+--------------------+

3.3.4.

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. 2. 3. 4. 5. 6. Uma cláusula WHERE pode combinar vários operadores AND e OR. O operador AND tem maior precedência que o operador OR. Os operadores de comparação tem maior precedência que os conectivos AND e OR. Todos os operadores de comparação tem a mesma precedência. Operadores de igual precedência são calculados da esquerda para a direita. 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');

3.3.5.

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. 22/50

MySQL + APACHE + PHP 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.

3.3.6.

Operador BETWEEN

Busca valores entre uma faixa especificada: mysql> SELECT nome FROM alunos WHERE matricula BETWEEN '100' AND '300';

3.3.7.

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

3.3.8.

Concatenando dados

sintaxe: CONCAT(campo1, campo2) mysql> SELECT matricula, nome, CONCAT(matricula, nome) FROM alunos;

3.3.9.

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

3.3.10.

Truncando valores

TRUNC (col/value,n) - Trunca campo, expressão ou valor para n casas decimais, se n for omitido, 23/50

MySQL + APACHE + PHP 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

3.3.11.

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

3.3.12.

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

3.3.13.

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.

3.3.14.

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;

24/50

MySQL + APACHE + PHP OBS: É uma função que pode se tornar muito útil.

3.3.15.

Soma

SUM (campo) - Retorna a soma dos valores de um campo dos registros de um tabela: mysql> SELECT SUM(campo) FROM tabela;

3.3.16.

Média

AVG (campo) - Retorna a média dos valores de um campo dos registros de um tabela: mysql> SELECT AVG(campo) FROM tabela;

3.3.17.

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;

3.3.18.

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;

3.3.19. 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 25/50

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

3.4. 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.

3.5. 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 26/50

MySQL + APACHE + PHP
• • • • •

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.

3.5.1.

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 | |

27/50

MySQL + APACHE + PHP
| 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_pri | 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 User password Select_priv Insert_priv Update_priv Delete_priv Create_priv Drop_priv Reload_priv Shutdown_priv Process_priv File_priv Grant_priv Index_priv Host de origem para conexão. Usuário a obter o acesso. senha. Permissão para executar SELECTs. Permissão para executar insert. Permissão para executar update. Permissão para executar delete. Permissão para executar create. Permissão para executar drop table. Permissão para recarregar informações via mysqladmin reload. Permissão para executar shutdown no servidor. Permissão para gerenciar processo no servidor. Permissão para ver ou gravar arquivos. Permissão para ceder seus privilégios a outros. Permissão para criar índices. 28/50

MySQL + APACHE + PHP Alter_priv Show_db_priv 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. Permissão para executar alter table. Permissão para executar show table.

3.5.2.

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: 29/50

MySQL + APACHE + PHP Campo Host Db User Select_priv Insert_priv Update_priv Delete_priv Drop_priv Index_priv Alter_priv Descrição Host de origem para conexão. Banco de dados selecionado. Usuário a obter acesso Permissão para executar SELECT. Permissão para executar insert. Permissão para executar update. Permissão para executar delete. Permissão para executar drop table. Permissão para criar índices. 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');

3.5.3.

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;

3.6. 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, 30/50

MySQL + APACHE + PHP 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

31/50

MySQL + APACHE + PHP

4. Compilando o Apache 2 com PHP e MySQL
Primeiramente vamos começar fazendo os downloads necessários. MySQL: http://www.mysql.com/downloads/mysql-4.0.html (pegue o tarball do source) Apache: http://apache.usp.br/httpd/ (pegue a versão 2.x.x) PHP: http://www.php.net/downloads.php Agora, depois de fazer os devidos downloads, vamos instalar o MySQL primeiro. Descompacte o arquivo: # tar zxvf mysql.xxx.tar.gz Entre no diretório descompactado: # cd mysql.xxx Configure-o para ser instalado no diretório /usr/local/mysql: # ./configure --prefix=/usr/local/mysql Compile e instale: # make # make install Após terminar isso, edite o arquivo /etc/ld.so.conf e insira a seguinte linha: /usr/local/mysql/lib/mysql E depois execute o comando: # ldconfig Assim o MySQL já vai estar instalado perfeitamente. Agora vamos a parte do Apache2 com o PHP. Essa parte é mais uma tradução do que está no site do PHP, que pode ser acessado pelo link abaixo: • http://www.php.net/manual/en/install.apache2.php Onde adaptei ou modifiquei algumas coisas pra ficar mais fácil de entender. Para descompactar o Apache:

32/50

MySQL + APACHE + PHP # tar zxvf httpd-2_0_NN.tar.gz Para descompactar o PHP: # tar zxvf php-NN.tar.gz Entre na pasta do Apache: # cd httpd-2_0_NN SSL: caso deseje habilitar suporte ao SSL no Apache, será necessário ter o pacote OpenSSL instalado no seu sistema operacional. Ao executar o script ./configure, adicione o seguinte parâmetro à ele: --enable-ssl. Execute: # ./configure --enable-so # make # make install Isso irá configurar, compilar e instalar seu Apache2. Para testá-lo, use o comando: # /usr/local/apache2/bin/apachectl start Testado e funcionando? Então pare ele com o comando abaixo para que possa ser configurado o PHP: # /usr/local/apache2/bin/apachectl stop Entrando no diretório do PHP: # cd ../php-NN Agora vamos configurar o PHP. Você poderá usar várias opções no ./configure, veja quais são as disponíveis com o comando:

33/50

MySQL + APACHE + PHP $ ./configure --help Mas como vamos colocar suporte a Apache2 e MySQL, precisaremos dos seguintes parâmetros: # ./configure --with-apxs2=/usr/local/apache2/bin/apxs --with-mysql E em seguida: # make # make install Se você decidir mudar as opções de configuração após a instalação, vai precisar repetir os últimos três passos. E assim apenas reiniciar o Apache para que o novo módulo faça efeito. Não é necessário recompilar o Apache. Agora vamos instalar o arquivo php.ini: # cp php.ini-dist /usr/local/lib/php.ini Edite o seu httpd.conf que fica em /usr/local/apache2/conf para carregar o módulo do PHP. Adicione a linha de acordo com a versão do php que você baixou. Para PHP 4: LoadModule php4_module libexec/libphp4.so Para PHP 5: LoadModule php5_module libexec/libphp5.so Adicione as seguintes linhas também ao httpd.conf: AddType application/x-httpd-php .php .phtml AddType application/x-httpd-php-source .phps Então é só iniciar o Apache e testar: # /usr/local/apache2/bin/apachectl start Para fazer a página de testes, siga os procedimentos abaixo: # touch /usr/local/apache2/htdocs/info.php # echo "<? phpinfo() ?>" > /usr/local/apache2/htdocs/info.php E assim acesse pelo browser a URL: http://localhost/info.php :-) Pronto, está feito.

34/50

MySQL + APACHE + PHP

Nesse tutorial você aprendeu a compilar o Apache2, PHP e MySQL utilizando como base a distribuição Slackware. Por: Thiago Alves

35/50

MySQL + APACHE + PHP

5. Implementando scripts PHP com MySQL
5.1. Introdução
Implementando scripts PHP com MySQL é uma continuidade da série "Gerenciando banco de dados com MySQL", que teve uma boa aceitação pelo público, que me enviou muitos pedidos para demonstrar seu uso com o PHP. Neste artigo vou falar de conceitos simples, de nível básico para usuários que estão iniciando no mundo da programação com PHP.

5.2. O que é PHP?
Foi chamado originalmente de Personal Home Page Tools por seu criador, o engenheiro de software Rasmus Lerdorf, que o desenvolveu com o intuito de monitorar os acessos de seu site pessoal. Sua segunda versão foi chamada de PHP/FI, que é a inclusão do Form Interpreter, uma ferramenta para analisar sintaticamente consultas SQL. Mas desde sua versão 3, está sobre a rubrica de Zend.com dos desenvolvedores Zeev Suraski e Andi Gutmans. O PHP é uma linguagem de criação de scripts embutida em HTML, que faz o mesmo papel do CGI, isto é, ele executado e interpretado do lado do servidor, retornando apenas o resultado para o browser do cliente. Isto significa que, ao analisar o código fonte de uma página feita em PHP, o usuário apenas visualizará códigos HTML, pois a sintaxe dele foi interpretada para isso. Basicamente, hoje em dia é possível se fazer de quase tudo em PHP, desde geração de páginas dinâmicas até a aplicação de comandos em seu servidor. Outro ponto muito importante é que o PHP aceita suporte a um grande número de banco de dados, como dBase, Interbase, mSQL, MySQL, Oracle, Sybase, PostgreSQL e outros. O PHP também tem suporte a serviços de protocolos como IMAP, SNMP, NNTP, POP3, sendo possível abrir sockets e interagir com outros protocolos.

5.2.1.

Criando uma aplicação

A sintaxe de PHP que iremos utilizar é a seguinte: <? comandos ... ?> Bem simples não... 1° Script - Vamos ao tradicional "Olá Mundo!" que aqui será o nosso "Olá Web!!!" <? // ola.php echo "Olá Web!!!"; echo "Eu estou utilizando o PHP para a criação desta página"; 36/50

MySQL + APACHE + PHP ?> Nota: Observe que o "echo" é o comando que imprime o texto na tela do browser, chamo a atenção também para o "ponto e vírgula", pois é ele que finaliza a instrução. 2° Script - Vamos agora a execução de um comando, como o SE, isto é, IF. <? // if.php /* Este exemplo utiliza o comando if e também comentários */ if (0 == 0) { // esta linha não precisa de ponto e vírgula echo "Se zero é igual a zero, este texto será apresentado!"; } else { // esta linha não precisa de ponto e vírgula echo "Se zero for diferente de zero, este texto será apresentado!"; // esta linha não precisa de ponto e vírgula } ?> Nota: Neste exemplo foi dado duas situações de utilização de comentário. Primeiro com o uso do /* texto */, que é utilizado para se fazer comentários que se estendem por mais de uma linha; Segundo com uso do //, que é utilizado para se fazer comentários em apenas uma linha. Em seguida foi dado um comando de estrutura de controle, que faz um redirecionamento do fluxo em resposta a um questionamento do comando if. Observe que nesta linha não é necessário utilizar o "ponto e vírgula". 3° Script - Vamos agora a utilização de variáveis <? // variaveis.php $num = 0; for ($num ; $num < 5; $num ++) { if ($num <= 2) { echo "O número $num é menor ou igual a 2"; } else { echo "<br> O número $num é maior que 2"; } // esta chave finaliza o bloco do comendo if } // esta chave finaliza o bloco do comando for ?> Nota: Começamos este script inicializando uma variável com o nome de "num", observe que para um nome ser considerado variável, ele deve ser iniciado com o $ cifrão. Foi utilizado o comando de repetição "for" que cria um loop até que sua condição seja quebrada. Sintaxe: for (variável_inicial ; condição ; incremento_ou_decremento_da_variável) for ($num ; $num < 5; $num ++)

37/50

MySQL + APACHE + PHP A cada passagem pelo comando for, de acordo com o valor da variável, ela será escrita na tela. Quero chamar a atenção para o incremento "++" que irá acrescer mais 1 a variável $num a cada passagem do for, mas observe que o valor 5 não será escrito, pois ele não entra na condição, ele é apenas um ponto determinante que quebra a repetição do for. Já o valor 2, será escrito por este estar sendo descrito na condição if como sendo (igual ou menor `=<` ao valor). Outro detalhe utilizado, foi a tag <br> do HTML, que irá fazer a mudança de linha para números maiores que 2, para deixar o texto exibido no browser mais organizado... como vocês irão perceber na comparação do resultado.

5.2.2.

Tipos de dados

Para você que está acostumado com programação, deve ter sentido falta da declaração do tipo de variável, e para quem não entendeu o que eu disse, quero dizer que em outras linguagens de programação, faz-se necessário especificar que tipo de dados aquela variável irá aceitar ou suportar. No PHP isto não é necessário, porque ele utiliza a checagem de tipos automaticamente, isto é, uma mesma variável pode conter tipos diferentes em vários momentos da execução de seu script. Os tipos de dados suportados pelo PHP são:
• • • • • •

Inteiro; Ponto flutuante; String; Array; Objeto; Data e hora.

4° Script - Vamos agora alternar os tipos em uma variável. <? // tipos.php echo "Vamos testar vários tipos agora!</p>"; for ($num=0 ; $num < 5; $num ++) { switch ($num) { case 0: // compara o valor 0 com a variável $num $tipo = 1000; print "Nosso tipo agora é o número $tipo"; break; case 1: $tipo = "100,01"; print "<br> Nosso tipo agora é o valor $tipo"; break; case 2: $tipo = "azul"; 38/50

MySQL + APACHE + PHP print "<br> Nosso tipo agora é a cor $tipo"; break; case 3: $tipo = 10 + 15; print "<br> Nosso tipo agora é a soma de 10 + 15 que é igual a $tipo"; break; case 4: $tipo = array (1 => "RJ", 2 => "SP", 3 => "MG"); $valor = 1; print "<br>Nosso tipo agora é um array com os estados de:"; while($valor <= sizeof($tipo)) { print " $tipo[$valor];"; $valor++; } break; } } ?> Nota: Iniciamos o script com uma mensagem, depois utilizamos novamente o comando de repetição "for", depois utilizamos o comando "switch" que testa linha a linha seus cases comparando-o com a variável informada, quando este valor casa, ele executa os comandos abaixo, mesmo os que fazem parte de outro case, até o fim do bloco, por isso usa-se o comando break, quebrando o fluxo no ponto desejado. Um tipo interessante que foi utilizado é o "array" ou vetor, que pode armazenar uma coleção de dados. Abaixo dele, foi utilizado um outro comando de repetição, o "while", que continua executando suas atividades até que sua condição seja quebrada. while ($valor <= sizeof($tipo)) Neste caso, especificamos que ele continuasse a ser executado enquanto a variável $valor que foi inicializada com 1, fosse menor que a posição do último dado armazenado no array, e para descobrimos isso utilizamos a função "sizeof(array)", que neste caso retornou o valor 3, que foi a quantidade de estados armazenados. Outro detalhe interessante é que desta vez utilizamos o comando "print" ao invés de "echo".

5.2.3.

Uso de função

Como em toda linguagem de programação, o uso de função é muito utilizado e recomendado, pois com ele podemos aproveitar uma série de comandos que podem ser aproveitados em outros scripts, não necessitando de ser reescritos novamente. Sintaxe: 39/50

MySQL + APACHE + PHP
function nome_da_função(argumentos) { comandos... }

5° Script - Vamos agora a alguns exemplos de função. <? // funcao.php // função simples para exibir um texto function exibe($texto) { echo $texto; } // função para somar dois valores function soma($num1, $num2) { $resultado = $num1 + $num2; echo $resultado; } // função para descobrir se um número é par ou ímpar function par_impar($num) { if (($num / 2) == 0) { echo " $num é um número par!"; } else { echo "$num é um número ímpar!"; } } //marca de comentário exibe("estou testando a primeira função!"); echo "<br><br>"; soma(30,50); echo "<br><br>"; par_impar(2345); echo "<br><br>"; //fim de marca de comentário ?> Nota: Neste exemplo foram criadas 3 funções (exibe, soma e par_impar). Para que elas sejam utilizadas, só é necessário escrever seu nome e entre parênteses passar o argumento que será processado. 6° Script - Neste script vamos dar um exemplo de reutilização de função OBS: Para este script dar certo, grave-o no mesmo diretório do script anterior e comente as linhas de "//marca de comentário" até "//fim de marca de comentário". Lembrando que para isso você pode utilizar os " /* conteúdo */ ". <? 40/50

MySQL + APACHE + PHP // nova_funcao.php include 'funcao.php'; exibe("Vamos utilizar o script funcao.php para executar as aplicações desejadas neste script!"); echo "<br><br>"; exibe("Ao somar-mos os valores 2345 com 45323, descobrimos que seu resultado é: "); $resultato_da_soma = soma(2345,45323); echo "<br><br>"; exibe("Agora vamos descobrir se o resultado da soma acima é um valor par ou ímpar!"); echo "<br>"; soma(2345,45323); par_impar($resultado_da_soma); echo "<br><br>"; exibe("Gostou do exemplo?"); ?> Nota: Neste exemplo a novidade foi o uso do comando "include", que lhe permite incluir um outro script dentro do script atual. Desta forma podemos nos beneficiar das funções criadas anteriormente sem precisar reescrevê-las novamente, poupando assim a redundância de códigos em dentro de seus scripts.

5.3. Criando um banco de dados para uso em nossos scripts
Vamos utilizar agora os mesmos comandos que vocês aprenderam lendo os artigos anteriores sobre banco de dados. Então, partindo do princípio que seu sistema já está configurado adequadamente, entre no MySQL e comece a executar os comandos abaixo: Criando um banco de dados: mysql> CREATE DATABASE meubanco; Criando uma tabela: mysql> CREATE TABLE funcionarios ( codigo int(5) NOT NULL auto_increment, nome varchar(40) NOT NULL default '', cargo varchar(25) NOT NULL default '', setor varchar(25) NOT NULL default '', PRIMARY KEY (codigo) ) TYPE=MyISAM; Inserindo alguns dados: mysql> INSERT INTO funcionarios Silva','Contador','Depto Pessoal'); (nome, cargo, setor) VALUES ('Marcos

41/50

mysql> INSERT INTO funcionarios Carneiro','Auxiliar','Depto Informática');

(nome,

cargo,

MySQL + APACHE + PHP setor) VALUES ('Lucas

mysql> INSERT INTO funcionarios (nome, cargo, setor) VALUES ('Jefferson Estanislau da Silva','Administrador','Depto Informática'); Nota: Como o campo "codigo" será automaticamente incrementado, não é necessário especificá-lo. Bom, agora que já criamos um banco de dados, tabela e inserimos alguns dados, vamos a uma questão muito importante, que é o usuário que poderá acessar, incluir e excluir dados desta tabela. Importante: Lembre-se que o MySQL possui um bando de dados padrão e de controle chamado "mysql". Acessando o banco de dados mysql: mysql> use mysql; Listando suas tabelas; mysql> show tables; Observe que dentre as tabelas listadas estão a User (responsável por definir o acesso do usuário ao servidor do mysql) e a Db (responsável por definir o acesso do usuário a um banco de dados específico). Desta forma, iremos criar um usuário que terá acesso ao nosso banco de dados e a tabela funcionário. Listando a estrutura da tabela user: mysql> show fields from user; Observe que foi listado o privilégio de comandos como Select, Insert, Delete e etc, onde deveremos indicar se nosso usuário poderá ou não se valer destes comandos. NOTA: Conte quantos campos de tipo "enum('N','Y')" foi listado, pois observei diferenças entre algumas distros. No Mandrake 9.1 onde escrevi o artigo anterior existem 21 campos. No Debian onde estou escrevendo este artigo existem 14 campos. Criando usuário para acesso no servidor: mysql> INSERT INTO user VALUES ('localhost', 'jeffestanislau', password('senhaphp'), 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y'); Nota: Nos 3 primeiros campos estou inserindo informações de Host, Usuário e Senha, para os demais estou dando a permissão para que ele possa usufruir de todos os comandos de manipulação. Listando a estrutura da tabela db: 42/50

MySQL + APACHE + PHP mysql> show fields from db; NOTA: Da mesma forma que em User, conte quantos campos de tipo "enum('N','Y')" foi listado. No Mandrake 9.1 existem 12 campos. No Debian existem 10 campos. Criando usuário para acesso ao banco de dados: mysql> INSERT INTO user VALUES('localhost', 'meubanco', 'jeffestanislau', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y'); NOTA: Os 3 primeiros campos desta vez correspondem há Host, banco de dados e usuário. Feito isso já estamos prontos para implementar o MySQL com o PHP.

5.4. Fazendo o PHP se comunicar com o MySQL
Vamos criar agora os scripts que farão a comunicação com o banco de dados. 7° Script - Neste script vamos criar uma função que fará a conexão com o bando de dados. <? // config.php function conectar() { $hostdb = 'localhost'; //host em que se dará a transação $db = 'meubanco'; //banco de dados $userdb = 'jeffestanislau'; //usuário que tem acesso $passdb = 'senhaphp'; //senha deste usuário if ($con = mysql_pconnect($hostdb,$userdb,$passdb)) { return $con; //se a conexão for bem sucedida, será retornado a variável $con } else { //se a conexão não ocorrer, será retornado 0 return 0; } } ?> NOTA: Este script será utilizado pelos demais scripts que necessitaram se comunicar com o bando de dados. 8° Script - Este script envia os dados para nosso banco de dados. <? // enviardados.php include 'config.php'; // conectar ao bando de dados $con = conectar(); // $con recebe o resultado da função conectar 43/50

MySQL + APACHE + PHP mysql_select_db('meubanco'); //função nativa do PHP que faz a conexão ao banco de //dados do MySQL //cadastrar cliente $insert = "INSERT INTO funcionarios (nome, cargo, setor) VALUES ('$nome', '$cargo', '$setor')"; mysql_query($insert,$con); //função nativa do PHP que faz a execução da query no //no banco de dados //mensagem informando o cadastro echo "Seu cadastro foi efetuado com sucesso!"; ?> <p align="center"><a href="inicio.html">Principal</a> NOTA: O script acima é simples, ele apenas efetua o cadastro. Observe que foi inserido dentro da variável $insert, uma string idêntica a utilizada dentro do MySQL, que será enviada pela função "mysql_query" para o servidor MySQL que executará a linha inserindo os dados. 9° Script - Este script obtém os dados armazenados em nosso banco de dados. <? // obterdados.php include 'config.php'; $con = conectar(); mysql_select_db('meubanco'); $select = "SELECT codigo, nome, cargo, setor FROM funcionarios WHERE nome LIKE '%$busca%')"; $res = mysql_query($select,$con); list($codigo, $nome, $cargo, $setor) = mysql_fetch_array($res); $cont = mysql_num_rows($res); if ($cont == 1) { include 'editar.html'; } else { echo "<br><br><p align='center'>Registro não Encontrado <p> <p> <p align='center'><a href='inicio.html'>Principal</a>"; } ?> NOTA: O comando "LIKE '%$busca%'" faz uma busca sobre qualquer parte do nome do usuário, sendo que neste caso ele irá retornar o primeiro nome que casar com a string digitada. A variável "$res" irá receber todos os dados encontrado por esta conexão. 44/50

MySQL + APACHE + PHP A função "mysql_fetch_array" nativa do PHP, irá destrinchar os registros em cada campo da posição do array referente a busca ocorrida. O comando "list" receberá os campos do array preenchendo as variáveis indicadas. A função "mysql_num_rows" informa quantos registros foram encontrados pela pesquisa realizada. A variável "$cont" recebe a quantidade de registros encontrados e é o fator determinante da condição do comando "if" que retornará a chamada ao HTML de edição, ou a indicação de que não houve registro encontrado. 10° Script - Este script irá fazer a edição dos dados já armazenados em nosso banco de dados. <? // editardados.php include 'config.php'; $con = conectar(); mysql_select_db('meubanco'); $update = "UPDATE funcionarios SET codigo=$codigo, nome='$nome', cargo='$cargo', setor='$setor' WHERE codigo='$codigo'"; mysql_query($update,$con); //confirmar alteração de dados echo "Edição efetuada com sucesso!!!"; echo "<p align='center'><a href='inicio.html'>Principal</a>"; ?> NOTA: A condição de edição dos dados foi imposta sobre o código, por esta ser uma informação que não poderá ser alterada. 11° Script - Este script irá listar o conteúdo dos registros armazenados em nosso banco de dados. <? // listar.php include 'config.php'; $con = conectar(); mysql_select_db('meubanco'); //definir quantidade de registros por páginas $num_por_pagina = 15; /*descubra o número da página que será exibida se o número da página não for informado, definir 1 */ 45/50

MySQL + APACHE + PHP if (!$pagina) { $pagina = 1; } //definir o número de registro da página $primeiro_registro = ($pagina*$num_por_pagina) - $num_por_pagina; //consultar os registros da página atual $consulta = "SELECT codigo, nome, cargo, setor FROM funcionarios ORDER BY codigo LIMIT $primeiro_registro, $num_por_pagina"; $res = mysql_query($consulta,$con); //exibir o cabeçalho da tabela com os dados echo "<b>FUNCIONÁRIOS CADASTRADOS</b><br><br> <center> <table border=1> <tr> <td><b>Código</b></td> <td><b>Nome</b></td> <td><b>Cargo</b></td> <td><b>Setor</b></td> </tr>"; //exibir registros na tabela while (list($codigo, $nome, $cargo, $setor) = mysql_fetch_array($res)) { echo "<tr> <td>$codigo</td> <td>$nome</td> <td>$cargo</td> <td>$setor</td></tr>"; } echo "</table></center>"; //construir painel de navegabilidade $consulta = "SELECT COUNT(*) FROM funcionarios"; list($total_reg) = mysql_fetch_array(mysql_query($consulta,$con)); $total_paginas = $total_reg/$num_por_pagina; $prev = $pagina - 1; $next = $pagina + 1; //se página maior que 1, então temos link para a página anterior if ($pagina > 1) { $prev_link = "<a href=\"$PHP_SELF?pagina=$prev\">Anterior</a>"; } else { //senão não há link para a página anterior $prev_link = "Anterior"; 46/50

MySQL + APACHE + PHP } /*se numero total de páginas for maior que a página corrente, então temos link para a próxima página */ if ($total_paginas > $pagina) { $next_link = "<a href=\"$PHP_SELF?pagina=$next\">Próxima</a>"; } else { $next_link = "Próxima"; } /*vamos arredondar para o alto o numero de páginas que serão necessárias para exibir todos os resultados, com a função ceil() */ $total_paginas = ceil($total_paginas); $painel = ""; for ($x=1; $x<=$total_paginas; $x++) { if ($x==$pagina) { //se estivermos na página corrente, não exibir o link para visualização desta página $painel .= "[$x]"; } else { $painel .= "<a href=\"$PHP_SELF?pagina=$x\">[$x]</a>"; } } //exibir painel na tela echo "<br><p align='center'>$prev_link | $painel | $next_link"; echo "<br><p align='center'><a href='inicio.html'>Principal</a>"; ?> NOTA: Neste script aproveitei parte do código do artigo de Fábio (Paginação de resultados em PHP/MySQL) para que nossa tela tenha um painel de navegabilidade. Este script já é a própria tela de lista de registros, não tendo uma página HTML para interagir com ele.

5.5. Criando os HTMLs de interação com o usuário
Agora vamos criar as páginas que serão o front-end do usuário para a manipulação das informações no banco de dados. Estou partindo do princípio que você conhece as tags de HTML e o uso de formulários. 1° Html - Aqui vamos fazer a tela de cadastro de funcionários. <!-- cadastrar.html --> <html> <title>Cadastrando de Funcionário</title> <body> <b>CADASTRO DE FUNCIONÁRIO</b> <p align="justify">Preencha os campos abaixo: 47/50

MySQL + APACHE + PHP <br> <form name="formCadastrarFuncionario" method="post" action="enviardados.php"> <table> <tr> <td width=20%>Nome:</td> <td width=80%> <input type="text" name="nome" size="40"></td> </tr> <tr> <td>Cargo:</td> <td><input type="text" name="cargo" size="30"></td> </tr> <tr> <td>Setor:</td> <td><input type="text" name="setor" size="30"></td> </tr> </table> <br><br> <input type="submit" value="Cadastrar"> <input type="reset" value="Limpar"> </form> </body> </html> NOTA: O comando "action" dentro da tag do formulário irá fazer a chamada ao script PHP. O comando "name" dentro da tag <input> deve ter seu nome igual a variável do script PHP que receberá esta informação. 2° Html - Aqui vamos fazer a tela de busca por um funcionário. <!-- buscar.html --> <html> <title>Buscar Funcionário para Editar seus Dados</title> <body> <b>BUSCAR FUNCIONÁRIO</b> <p align="justify">Entre com o nome do funcionário: <br> <form name="formBuscarFuncionário" method="post" action="obterdados.php"> <table> <tr> <td width=20%> Nome:</td> <td width=80%> <input type="text" name="buscar" size="40"</td> </tr> </table>

48/50

MySQL + APACHE + PHP <br><br> <input type="submit" value="Buscar"> <input type="reset" value="Limpar"> </form> </body> </html> 3° Html - Aqui vamos fazer a tela para editar os dados do funcionário. <!-- editar.html --> <html> <title>Editando dados do Funcionário</title> <body> <b>EDITANDO DADOS</b> <p align="justify">Altere os dados abaixo que achar necessário: <br> <form name="formEditarDados" method="post" action="editardados.php"> <table> <tr> <td width=20%>Código:</td> <td width=80%><input type="hidden" name="codigo" value="<? echo $codigo ?>" size="5"></td> </tr> <tr> <td width=20%>Nome:</td> <td width=80%><input type="text" name="nome" value="<? echo $nome ?>" size="40"></td> </tr> <tr> <td>Cargo:</td> <td><input type="text" name="cargo" value="<? echo $cargo ?>" size="30"></td> </tr> <tr> <td>Setor:</td> <td><input type="text" name="setor" value="<? echo $setor ?>" size="30"></td> </tr> </table> <br><br> <input type="submit" value="Editar"> <input type="reset" value="Limpar"> </form> </body> </html> NOTA: Lembre-se que este HTML será chamado ao final do script "obterdados.php", que repassará 49/50

MySQL + APACHE + PHP as informações que preencherão os campos do formulário através das variáveis $codigo, $nome, $cargo, $setor, chamadas a partir da tag do PHP <? echo $nome_variável ?>. 4° Html - Aqui vamos fazer a tela que será nossa página inicial. <!-- inicio.html --> <html> <title>Página Inicial</title> <body> <b>Escolha a tarefa a ser executada:</b> <p align='center'><a href='cadastrar.html'>Cadastrar Funcionário</a> <p align='center'><a href='buscar.html'>Editar Funcionário</a> <p align='center'><a href='listar.php'>Visualizar Registros de Funcionários</a> </body> </html> Comentário: Show de bola né... agora você já pode brincar com os scripts e os formulários para o cadastro dos funcionários.

5.6. Conclusão
Como disse no início do artigo, aqui vim descrever apenas comandos básicos para usuários que estão começando no mundo da programação PHP e querem interagir com o banco de dados MySQL. Já os usuários mais experientes, devem ter notado que não demonstrei o uso de rotinas de verificação, ou comandos mais avançados do PHP que preservam sua segurança, pois deixo isso como meta para estes usuários se aprofundarem por conta própria na linguagem, ou quem sabe, para que eu possa escrever uma continuação deste artigo. Quero agradecer a todos os usuários que leram os meus artigos que antecederam a este e enviaram mensagens de apoio e satisfação por terem aprendido um pouco com o que ensinei, sendo estes, os incentivadores destas linhas escritas acima. Obrigado a todos! Jefferson Estanislau da Silva Analista de Sistemas jefferson@rootmaster.com.br ou jeffestanislau@vivaolinux.com.br

50/50


				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:150
posted:11/24/2008
language:Czech
pages:50