Apostila
1. INTRODUÇÃO ____________________________________________________________________ 4
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
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
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
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.
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:
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.
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:
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.
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 &
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 Descrição
INT Valor inteiro
REAL Valor de ponto flutuante
Valor de caractere de tamanho fixo. Valor inferior ao definido será deixado
CHAR(tamanho)
em branco.
TEXT(tamanho) 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 Valor para datas do tipo (AAAA-MM-DD)
TIME Valor de tempo padrão
DATETIME Valor para data e hora agregados.
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 Varchar(5) *
nome Varchar(50)
endereco Varchar(50)
cidade Varchar(30)
codcurso char(2)
Tabela CURSOS:
Nome do campo Tipo de dado
codcurso char(2) *
nomecurso Varchar(50)
coddisc1 char(2)
coddisc2 char(2)
coddisc3 char(2)
Tabela DISCIPLINAS:
Nome do campo Tipo de dado
coddisciplina char(2) *
nomedisciplina Varchar(30)
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.
9/50
MySQL + APACHE + PHP
Para podermos criar a base de dados a partir de nosso modelo, observe a sintaxe a seguir:
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.
Agora que já criamos a base de dados e ela está em uso, poderemos criar as nossas tabelas.
10/50
MySQL + APACHE + PHP
-> primary key(coddisciplina) );
Query OK, 0 rows affected (0.00 sec)
Para corrigirmos isso, iremos utilizar o comando ALTER TABLE e usar os parâmetros ADD e
CHANGE.
Muito bem! Agora nossas tabelas estão de acordo com o modelo proposto.
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)
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!
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.
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.
O comando utilizado para inserir dados nas tabelas é o INSERT, veja a sintaxe abaixo para se usar
este comando:
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)
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.
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".
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?
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)
Exemplo5: Visualizar todos os campos da tabela alunos, ordenando-os pelo campo nome.
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:
15/50
MySQL + APACHE + PHP
Esclarecendo as informações da sintaxe a cima:
tabela1.campo campo a ser exibido
tabela2.campo campo a ser exibido
tabelas nome das tabelas a serem usadas
tabela1.campo_chave campo chave para junção
tabela2.campo_comum campo comum para junção
qualquer uma das tabelas
tabela.campo
indicadas
valor valor para referência da condição
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)
UPDATE tabela
SET campo = valor
WHERE {condição};
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
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:
Observe que usei para esta condição o número da matrícula, mas poderia ter usado o valor de
qualquer campo.
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.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.
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.
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
);
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
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") ...
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
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.
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.
+-------------------------------+
| nome |
+-------------------------------+
| Jefferson Estanislau da Silva |
| Leila Maria Muniz da Silva |
| Victor Estanislau da Silva |
+-------------------------------+
+-------------------------------+
| INSCRITOS |
+-------------------------------+
| Jefferson Estanislau da Silva |
| Leila Maria Muniz da Silva |
| Victor Estanislau da Silva |
+-------------------------------+
// observe que o nome das tabelas ALUNOS e CURSO são repetidos constantemente dentro desta
cláusula.
// observe que foi utilizado o apelido A para AlUNOS e C para CURSOS, simplificando assim o
código.
21/50
MySQL + APACHE + PHP
| Jefferson Estanislau da Silva | Ensino Medio |
| Leila Maria Muniz da Silva | Ensino Medio |
| Victor Estanislau da Silva | Ensino Fundamental |
+-------------------------------+--------------------+
NOTA: é possível utilizar operadores de comparação lógica, estes estão divididos em duas classes:
Precedência de operadores
mysql> SELECT nome FROM alunos WHERE matricula > '100' AND (cidade = 'Nova Friburgo'
OR codcurso='01');
22/50
MySQL + APACHE + PHP
mysql> SELECT nome FROM alunos WHERE nome LIKE 'J%';
3.3.7. Operador IN
Uso de funções
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
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
CEIL (col/value) - Encontra o menor inteiro maior ou igual a campo, expressão ou valor:
mysql> SELECT CEIL(campo) FROM tabela;
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;
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;
MAX (campo) - Retorna o maior valor entre todos os valores de um campo dos registros de um
tabela:
mysql> SELECT MAX(campo) FROM tabela;
MIN (campo) - Retorna o menor valor entre todos os valores de um campo dos registros de um
tabela:
mysql> SELECT MIN(campo) FROM tabela;
COUNT(*) - Retorna o número de linhas em uma tabela, incluindo linhas duplicadas e linhas
contendo valores NULL.
25/50
MySQL + APACHE + PHP
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);
OBS: os operadores de comparação situam-se em duas classes: operadores de linha única (>, =, >=,
<, <>, <=) e operadores de várias linhas (IN, NOT IN).
Regras Gerais
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.
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.
+-----------------+
| Tables_in_mysql |
+-----------------+
| columns_priv |
| db |
| func |
| host |
| tables_priv |
| 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 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.
28/50
MySQL + APACHE + PHP
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.
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.
+-----------------------+-----------------+------+-----+---------+-------+
| 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 | |
+-----------------------+-----------------+------+-----+---------+-------+
29/50
MySQL + APACHE + PHP
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.
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');
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
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.
Por
Jefferson Estanislau da Silva
Analista de Sistemas
jeffestanislau@hotmail.com
31/50
MySQL + APACHE + PHP
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:
# cd mysql.xxx
# ./configure --prefix=/usr/local/mysql
Compile e instale:
# make
# make install
/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.
32/50
MySQL + APACHE + PHP
# tar zxvf httpd-2_0_NN.tar.gz
# 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
# 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:
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.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.
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.
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.
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".
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.
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.
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.
• Inteiro;
• Ponto flutuante;
• String;
• Array;
• Objeto;
• Data e hora.
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.
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".
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...
}
//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.
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("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.
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:
41/50
MySQL + APACHE + PHP
mysql> INSERT INTO funcionarios (nome, cargo, setor) VALUES ('Lucas
Carneiro','Auxiliar','Depto Informática');
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".
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.
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.
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.
42/50
MySQL + APACHE + PHP
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.
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.
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 {
return 0; //se a conexão não ocorrer, será retornado 0
}
}
?>
NOTA: Este script será utilizado pelos demais scripts que necessitaram se comunicar com o bando
de dados.
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')";
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.
$con = conectar();
mysql_select_db('meubanco');
$res = mysql_query($select,$con);
$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_num_rows" informa quantos registros foram encontrados pela pesquisa realizada.
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');
mysql_query($update,$con);
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');
/*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;
}
$res = 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>";
}
}
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.
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.
<b>CADASTRO DE FUNCIONÁRIO</b>
<p align="justify">Preencha os campos abaixo:
47/50
MySQL + APACHE + PHP
<br>
<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.
<b>BUSCAR FUNCIONÁRIO</b>
<p align="justify">Entre com o nome do funcionário:
<br>
48/50
MySQL + APACHE + PHP
<br><br>
<input type="submit" value="Buscar">
<input type="reset" value="Limpar">
</form>
</body>
</html>
<b>EDITANDO DADOS</b>
<p align="justify">Altere os dados abaixo que achar necessário:
<br>
<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>
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!
50/50