Uma função para você poder calcular a Idade a partir de um DateTime:

public int CalculaIdade(DateTime DataNascimento)
{
 int anos = DateTime.Now.Year - DataNascimento.Year;
 if (DateTime.Now.Month < DataNascimento.Month || (DateTime.Now.Month == DataNascimento.Month && DateTime.Now.Day < DataNascimento.Day))
 anos--;
 return anos;
}

Rápido, rasteiro e voando!

Por um pouco que pesquisei vi que o problema era o UTF-8 e os arquivos salvos com o BOM.

A solução é fácil, alterar o encoding de todos os arquivos para UTF-8 sem BOM (Notepad++ faz isso).

Como uso Zend, Smarty e Doctrine para criar minhas aplicações em PHP, tenho cerca de uns 15.000 arquivos divididos nas mais “filhas da putas” pastas, impossível de ser realizado “manualmente”.

Para tanto, escrevi um código em C# que vai recursivamente acessando as pastas e verificando se o arquivo tem BOM e caso tenha, o remova.

Segue código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace SuperMigueBomRemover
{
    class Program
    {

        public static string path_inicial = "D:\\bom_remover\\";

        #region SOME DEMONHO
        static void Main(string[] args)
        {
            //Executa o método de run
            (new Program()).run(path_inicial);
        }
        #endregion

        public void run(string path)
        {
            DirectoryInfo diretorio = new DirectoryInfo(@path);
            FileInfo[] arquivos = diretorio.GetFiles("*.*");
            DirectoryInfo[] subDiretorios = diretorio.GetDirectories();

            string temp;

            foreach (FileInfo file in arquivos)
            {
                //Guardo o caminho do arquivo em temp
                temp = path + file.Name;
                this.trataOBomDoInferno(temp);
            }
            foreach (DirectoryInfo dir in subDiretorios)
            {
                //Guardo o caminho do subDir em temp
                temp = string.Format("{0}{1}\\", path, dir.Name);
                System.Console.WriteLine("Aplicando recursão no diretório {0}\n", temp);
                this.run(temp);
            }
            return;
        }

        private void trataOBomDoInferno(string file)
        {
            if (new string[] { "html", "php", "htm", "css", "js", "txt", "xml" }.Where(p => file.EndsWith(p)).Count() > 0)
            {
                System.Console.WriteLine("Tratando o arquivo {0}", file);
                if (File.Exists(file))
                {
                    System.Console.WriteLine("Existe: {0}\n", file);
                    StreamReader st = new StreamReader(file);

                    string texto = st.ReadToEnd();

                    st.Close();
                    Byte[] b = System.Text.Encoding.UTF8.GetBytes(texto);
                    Stream s = File.Create(file);
                    s.Write(b, 0, b.Length);
                    s.Close();
                }
                else
                {
                    System.Console.WriteLine("Não existe: {0}\n", file);
                }
            }
            else
            {
                System.Console.WriteLine("{0} é necessário ser tratado.", file);
            }
        }

    }
}

Para tanto, se faz necessário utilizar as seguintes bibliotecas:

using System.Net.Mail;
using System.Net;

Como iremos enviar um e-mail autenticado via SMTP, precisamos instanciar um objeto do tipo SmtpClient, habilitar o SSL (O Gmail pede SSL) e passar as credenciais (através do Objeto NetworkCredential) para o atributo Credentials. Segue código:

SmtpClient client = new SmtpClient();
client.Host = "smtp.gmail.com";
client.EnableSsl = true;
client.Credentials = new NetworkCredential("seulogin", "suasenha"); //PS.: não utilizar @gmail.com, é tudo antes do @. Ex.: william@gmail.com login = william

E agora iremos criar o E-mail propriamente dito e depois dispara-lo utilizando o método Send da classe SmtpClient. Segue o código:

MailMessage mail = new MailMessage(); //Instancio o Objeto do tipo MailMessage
mail.Sender = new MailAddress("williamokano@gmail.com", "William Okano"); //Defino quem está enviado
mail.From = new MailAddress("williamokano@gmail.com", "William Okano"); //Defino o return path
mail.To.Add(new MailAddress("william.okano@webroom.com.br", "William - Webroom")); //Adiciono um destinatário
mail.Subject = "Teste E-mail Console Application"; //Assunto do e-mail
mail.Body = "<strong>Teste</strong> de <em>e-mail</em> ( :"; //Corpo (mensagem) do e-mail (Em html pois logo abaixo ativamos o html)
mail.IsBodyHtml = true; //Avisamos que o e-mail é composto em HTML
mail.Priority = MailPriority.High; //Definimos a prioridade do e-mail como alta

E assim definimos nossa mensagem. Agora só falta disparar, e este, agora, é o mais fácil, sendo simplesmente:

client.Send(mail);

Você pode cercar tudo com um try-catch para saber caso dê algum erro, etc. Não entrarei no método de capturar excessão.

Bom galera, foi isso! Um beijo e um queijo, e até o próximo “artigo”.

Venho lhes apresentar hoje a primeira aula um novo projeto que estou fazendo, que será as vídeo aulas de programação.

Estou começando com PHP, conheço um pouco melhor e acho que será mais fácil.

Nesta primeira aula vou ensinar como criar um livro de visitas:

Segue

Bom, firulas a parte, hoje queria deixar uma coisa que me quebrou muito a cabeça em um servidor compartilhado e, talvez, por burrice minha, ou falta de atenção, acabou passando despercebido e isso me custou bastante tempo para resolver o problema.

Fui subir uma aplicação desenvolvida em php a um servidor linux, e pra minha surpresa, toda vez dava um raio de um erro 500, e o projeto lá no meu pc, lindo e funcionando.

Depois de muito pesquisar, descobri que o “problema” era um tal de suPHP, que já ouvira falar mas nunca instalei/utilizei.

O mod_suphp, substitui o mod_php e assim, dizem, que aumenta a segurança, etc, etc, etc. Só que pra rodar esse mod tem um “porém”:

• Suas pastas devem estar com permissão 755
• Seus arquivos devem estar com permissão 644

“Tá”, mas e aí? E aí que eu subi geral com 755 e com esse módulo ativo, ele simplesmente te retorna um internal server error, “daí” você fica sem saber o que ocorreu, visto que eu não tinha acesso aos logs de erro.

find /home/*/public_html -type d -exec chmod 755 {} \;
find /home/*/public_html -type f -exec chmod 644 {} \;

Como será utilizado C ANSI, poderá ser compilado em qualquer S.O. com suporte a linguagem (e pra ser sincero só testei em Windows e Linux).

Vamos lá.

Se você estiver utilizando Windows, ou alguma IDE, abra-a, mas nesse caso será necessário apenas um editor de texto.
Eu costumo utilizar o notepad++ pra windows ou no linux o scite, mas quem gosta do kate, gedit ou mesmo o vi, pode utiliza-lo sem problema.

Escreva o seguinte código:

#include <stdio.h>

int main(int argc, char* argv[]){
	printf("Hello world.\n");
	return 0;
}

Salve este arquivo como hello.c

Agora vamos lá ao comentário.

A Linha 1 é a inclusão do arquivo de assinaturas para entrada e saída básica.
Não confunda com biblioteca, pois ela não é (não a stdio.H).
A biblioteca em si está em algum lugar, já compilada, e apenas será linkada, mas precisa do arquivo de cabeçalho dela para poder utilizar as funções.

A terceira linha declara a função principal, ela não precisa dos argumentos passados (int argc, char* argv[]) nem do tipo de retorno, mas eu gosto de colocar.

A quarta linha é a saída, printf, ou seja, um print formatado (será abordado posteriormente em algum outro artigo).

E o return 0 é apenas para dizer ao sistema operacional que a função terminou.

Veja que se não haver a função main, nada será chamado, pois o compilador procura por esta função para dizer que ali é o entry point.

Como compilar!

Bom, se você está utilizando alguma IDE, você precisa fazer o build e depois o run e isso varia de IDE para IDE.
Sei que no Dev-Cpp (Windows) é o F9 (atalho) e no Code::Blocks é o F6, não me recordo agora qual é, mas está por aí, eu juro.

Se você estiver utilizando o Linux (ou se baixou o GCC para windows), digite o seguinte comando no terminal:

gcc hello.c -o hello

Se você estiver utilizando windows e compilando por linha de comando, é bom coloca no último hello a extensão “.exe”.

Se tudo correu bem, você irá executar o comando (./hello no linux ou hello.exe no windows) e ele escreverá na tela Hello World.

Bom, é só isso, um artigo singelo e logo logo tem mais.

Introdução

Neste artigo irei descrever alguns conceitos de Orientação a Objetos, utilizando a linguagem Java.

Para tanto, irei dividir o artigo em partes menores e irei posta-las conforme o tempo.

A divisão será feita da seguinte maneira:

• Programação Orientada a Objetos em Java
• Reconhecendo Objetos
• Criando um tipo e Criando e Usando um Objeto
• Métodos e Métodos com Retorno
• Modificadores de Acesso
• Métodos e Atributos Estáticos
• Herança
• Override
• Overload
• Classe e Método Abstrato
• Interface
• Excessões
• Pacotes

Programação Orientada a Objetos

A orientação a objetos é um paradigma de análise, projeto e programação de sistemas de software baseado na composição e interação entre diversas unidades de software chamadas de objetos. (Wikipédia ).

C++, C♯, VB.NET, Java, Object Pascal, Objective-C, Python, SuperCollider, Ruby e Smalltalk são exemplos de linguagens de programação orientadas a objetos. ActionScript, ColdFusion, Javascript, PHP (a partir da versão 4.0), Perl (a partir da versão 5) e Visual Basic 6,5 e 4 são exemplos de linguagens de programação com suporte a orientação a objetos.

Classe: representa um conjunto de objetos com características afins. Uma classe define o comportamento dos objetos através de seus métodos, e quais estados ele é capaz de manter através de seus atributos.
Exemplo de classe: Os seres humanos.

Subclasse: é uma nova classe que herda características de sua(s) classe(s) ancestral(is).

Objeto / instância de uma classe: um objeto é capaz de armazenar estados através de seus atributos e reagir a mensagens enviadas a ele, assim como se relacionar e enviar mensagens a outros objetos. Exemplo de objetos da classe Humanos: João, José, Maria

Atributo: são características de um objeto. Basicamente a estrutura de dados que vai representar a classe. Exemplos: Funcionário: nome, endereço, telefone, CPF,…; Carro: nome, marca, ano, cor, …; Livro: autor, editora, ano. Por sua vez, os atributos possuem valores. Por exemplo, o atributo cor pode conter o valor azul. O conjunto de valores dos atributos de um determinado objeto é chamado de estado

Método: define(m) o(s) comportamento(s) dos objetos.
Bidu é uma instância da classe Cachorro, portanto tem habilidade para latir, implementada através do método deUmLatido.
Um método em uma classe é apenas uma definição.
A ação só ocorre quando o método é invocado através do objeto, no caso Bidu.
Dentro do programa, a utilização de um método deve afetar apenas um objeto em particular.
Todos os cachorros podem latir, mas você quer que apenas Bidu dê o latido.
Normalmente, uma classe possui diversos métodos, que no caso da classe Cachorro poderiam ser sente, coma e morda.

Mensagem: é uma chamada a um objeto para invocar um de seus métodos, ativando um comportamento descrito por sua classe.
Também pode ser direcionada diretamente a uma classe (através de uma invocação a um método estático).

Herança (ou generalização): é o mecanismo pelo qual uma classe (sub-classe) pode estender outra classe (super-classe), aproveitando seus comportamentos (métodos) e variáveis possíveis (atributos).
Um exemplo de herança: Mamífero é super-classe de Humano. Ou seja, um Humano é um mamífero.
Há herança múltipla quando uma sub-classe possui mais de uma super-classe.
Essa relação é normalmente chamada de relação “é um”.

Associação: é o mecanismo pelo qual um objeto utiliza os recursos de outro.
Pode tratar-se de uma associação simples “usa um” ou de um acoplamento “parte de”.
Por exemplo: Um humano usa um telefone. A tecla “1″ é parte de um telefone.

Encapsulamento: consiste na separação de aspectos internos e externos de um objeto.
Este mecanismo é utilizado amplamente para impedir o acesso direto ao estado de um objeto (seus atributos), disponibilizando externamente apenas os métodos que alteram estes estados.
Exemplo: você não precisa conhecer os detalhes dos circuitos de um telefone para utilizá-lo.
A carcaça do telefone encapsula esses detalhes, provendo a você uma interface mais amigável (os botões, o monofone e os sinais de tom).

Abstração: é a habilidade de concentrar nos aspectos essenciais de um contexto qualquer, ignorando características menos importantes ou acidentais.
Em modelagem orientada a objetos, uma classe é uma abstração de entidades existentes no domínio do sistema de software.

Polimorfismo: consiste em quatro propriedades que a linguagem pode ter (atente para o fato de que nem toda linguagem orientada a objeto tem implementado todos os tipos de polimorfismo):
Universal:
Inclusão: um ponteiro para classe mãe pode apontar para uma instância de uma classe filha (exemplo em Java: “List lista = new LinkedList();” (tipo de polimorfismo mais básico que existe)
Paramétrico: se restringe ao uso de templates (C++, por exemplo) e generics (Java/C?)
Ad-Hoc:
Sobrecarga: duas funções/métodos com o mesmo nome mas assinaturas diferentes
Coerção: a linguagem que faz as conversões implicitamente (como por exemplo atribuir um int a um float em C++, isto é aceito mesmo sendo tipos diferentes pois a conversão é feita implicitamente)

Interface: é um contrato entre a classe e o mundo externo. Quando uma classe implementa uma interface, ela está comprometida a fornecer o comportamento publicado pela interface.

Pacotes: são referências para organização lógica de classes e interfaces.

Todos estes textos foram retirados da Wikipédia.

Só queria adiantar que existem vários métodos de se fazer isso e que esse é o que eu mais utilizo.

Eu acho melhor por ser uma classe, logo pode ser extendida, etc.

Bom, para listar os arquivos e diretórios você pode simplesmente intanciar um novo objeto do tipo DirectoryIterador passando o diretório como parâmetro no construtor e fazer um foreach nesse objeto. Segue exemplo:

$iterador = new DirectoryIterator("/home/william/");
foreach ( $iterador as $entrada ) {
	echo $entrada->getFilename(), "<br/>";
}

Você pode fazer ainda isso recursivamente, apesar de gostar de fazer manualmente. Segue o código:

$iterator = new RecursiveDirectoryIterator('/var/www');
$recursiveIterator = new RecursiveIteratorIterator($iterator);

foreach ( $recursiveIterator as $entry ) {
	echo $entry->getFilename(), "\n";
}

Até o próximo artigo, que acredito que será de java e POO!

Sim, é esse que estou utilizando atualmente, foi desenvolvido por mim, com ajuda do Claudney Santana do cuca digital.

Como eu subi no repositório do WordPress, é só pesquisar por “WP Super Redes Sociais” que você o encontrará.

Para configura-lo, depois de instalado e ativado, vá no menu esquerdo da sua dash board e acesse o CHW Plugins.

Lá você pode fazer todas as configurações, como mostrar qual o usuário do twitter deve ser o do via (ex.: via @williamokano).

Você pode escolher o idioma do facebook.

E você ainda pode editar o CSS.

É bem simples e nada mais é do que um “catadão” das API’s já fornecidas pelas redes sociais.

Se tiver alguma sugestão de melhoria ou crítica, alguma funcionalidade específica ou alteração que não esteja conseguindo fazer, ou tenha feito e quer me ajudar na melhoria deste, deixe um comentário!!!

Olá, neste artigo irei demonstrar brevemente como utilizar o banco de dados MySQL com PHP.

Também irei dar uma breve explicação sobre SQL, na qual você deverá se aprofundar melhor.

Só para deixar claro, irei utilizar o gerenciador fornecido pelo MySQL, o MySQL Workbench, que está na versão 5.2.34 quando escrevo este post.

Download do Mysql e do MySQL workbench podem ser realizados na página http://www.mysql.com/downloads/.

Vamos lá.

O que é banco de dados

Banco de dados (ou base de dados), é um conjunto de registros dispostos em estrutura regular que possibilita a reorganização dos mesmos e produção de informação.
Um banco de dados normalmente agrupa registros utilizáveis para um mesmo fim.
Um banco de dados é usualmente mantido e acessado por meio de um software conhecido como Sistema Gerenciador de Banco de Dados (SGBD).
Normalmente um SGBD adota um modelo de dados, de forma pura, reduzida ou estendida. Muitas vezes o termo banco de dados é usado, de forma errônea, como sinônimo de SGBD.
O modelo de dados mais adotado hoje em dia é o modelo relacional, onde as estruturas têm a forma de tabelas, compostas por tuplas (linhas) e colunas.
Fonte: Wikipedia.

O que é SQL

Structured Query Language, ou Linguagem de Consulta Estruturada ou SQL, é uma linguagem de pesquisa declarativa para banco de dados relacional (base de dados relacional). Muitas das características originais do SQL foram inspiradas na álgebra relacional.
Fonte: Wikipedia.

Comandos SQL

Comandos SQL tentam seguir um padrão, ANSI e ISO, porém algumas empresas costumar colocar alguns códigos próprios em seus gerenciadores, para otimização interna, etc.

Os comandos mais utilizados, e que vamos ver aqui, são os comandos para CRUD.

* CREATE – Comando Reponsável por criar uma tabela ou banco de dados, etc.
* INSERT – Comando Reponsável por inserir dados na tabela.
* SELECT – Comando responsável por buscar dados na tabela.
* UPDATE – Comando responsável por atualizar os dados de uma tabela.
* DELETE – Comando responsável por remover determinado dado (ou todos ) de uma tabela.
* TRUNCATE – Comando responsável por LIMPAR uma tabela. Até as chaves de auto incremento voltam ao início.

Exemplos

Alguns exemplos de uso. Como base, iremos tomar como base um sistema básico de usuários com hierarquia.

Um usuário tem os atributos id (único e auto incremento), nome, login, senha e classe.
Para id utilizaremos o tipo int.
Para nome, login e senha utilizaremos varchar.
E para classe também utilizaremos int.

Porque usar int na classe ao invés de utilizar varchar? Bom, isso é simples. Imagina que nós armazenamos a classe num atributo de texto, e temos 10000 usuários da classe usuário.
Beleza, até ai sem problema. Mas agora não queremos mais que a classe usuário se chame usuário e sim Users. Teríamos que mudar 10000 registros.

Com o relacionamento, simplesmente alterando a tabela relacionada e altera de todos, pois ele está relacionado com a ID (que não muda) do que com o nome da classe.

Bom, a nossa tabela de relacionamento irá armazenar apenas a ID e o nome da classe. Bem simples não?

Uma imagem de como irá ficar as tabelas e o relacionamento.

O código pra gerar essa tabela com o relacionamento eu postarei logo abaixo explicando-o.

CREATE SCHEMA IF NOT EXISTS `dados` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci ;
USE `dados` ;
-- -----------------------------------------------------
-- Table `dados`.`classes`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `dados`.`classes` (
  `id` INT NOT NULL AUTO_INCREMENT ,
  `nome` VARCHAR(45) NULL ,
  PRIMARY KEY (`id`) )
ENGINE = InnoDB;

-- -----------------------------------------------------
-- Table `dados`.`usuarios`
-- -----------------------------------------------------
CREATE  TABLE `dados`.`usuarios` (
  `id` INT NOT NULL AUTO_INCREMENT ,
  `nome` VARCHAR(45) NULL ,
  `login` VARCHAR(45) NULL ,
  `senha` VARCHAR(32) NULL ,
  `classe` INT NULL ,
  PRIMARY KEY (`id`) ,
  INDEX `idx_classe` (`classe` ASC) ,
  CONSTRAINT `idx_classe`
    FOREIGN KEY (`classe` )
    REFERENCES `dados`.`classes` (`id` )
    ON DELETE NO ACTION
    ON UPDATE NO ACTION)
ENGINE = InnoDB;

Bom, vamos lá, logo na primeira linha, vemos um CREATE SCHEMA `dados`, ou seja, vamos criar um esquema de dados chamado dados. Usualmente irei me referir a ele como nosso banco de dados.

USE `dados` quer dizer que todas as consultas posteriores serão aplicados a esse esquema.

CREATE TABLE IF NOT EXISTS `dados`.`classes` – Iremos criar uma tabela, apenas se não existir, chamada classes. Observe que utilizei `dados`.`classes`, que significa esquema e tabela.
Como utilizamos o USE anteriormente, isso é redundante, mas como estou utilizando o MySQL Workbench para criar as querys, ele gera isso sozinho.

Bom, fora o create, iremos definir os atributos dessa tabela classes, que são ID e NOME.

ID é do tipo INT (inteiro, integer), não pode ser nulo, ou seja, sempre terá um valor do tipo selecionado e é auto incrementado, ou seja, não precisamos definir qual a ID pois ela aumentará automáticamente a cada novo registro.

Definimos a chave primária como sendo a ID, ou seja, definimos que ela nunca irá se repetir, e ela será indexada, ou seja, a grosso modo dizendo, será mais rápido buscar por esse campo.

O atributo nome é do tipo VARCHAR, e não CHAR, ambos se referem a texto. A diferença de um para o outro você pode conferir neste link Os Tipos CHAR e VARCHAR

Os atributos da segunda tabela são muito parecidos, a única diferença que talvez você tenha notado, é que lá além da primary key, existem também INDEX, CONSTRAINT, FOREIGN KEY e REFERENCES.

Isso significa que estou criando outro índice, só que desta vez com uma “ligação”, “amarramento” (CONSTRAINT), que será nossa relação com a tabela classes

FOREIGN KEY é com qual tabela iremos relacionar com nossa “chave estrangeira” (FOREIGN KEY = Chave Estrangeira) e será referenciado o campo ID da tabela (REFERENCES (id)).

“ON DELETE NO ACTION” e “ON UPDATE NO ACTION” significa que ao deletar ou atualizar um registro com relacionamento, nada será feito. Geralmente realizar esta ação gera um erro de constraint.

Agora explicado como funciona o banco, vamos inserir alguns registros, utilizar os comandos anteriormente citados e logo após como utiliza-los em PHP.

Exemplo de Comando INSERT

O comando insert, serve para inserir dados. Existem vários jeitos de utilizar o comando, portante irei passar aqui apenas a sintaxe básica.

A sintaxe é a seguinte

INSERT INTO `nome_da_tabela` (campo1, campo2, campo3, campon) VALUES ('valor_campo1', 'valor_campo2', 'valor_campo3', 'valor_campon');

As aspas simples são necessárias quando se está utilizando Strings ou Datas, mas não são necessárias quando são números, e isso você verá quando formos inserir os dados dos usuários.

Observe o código de inserção de classes:

INSERT INTO `classes` (`nome`) VALUES ('Usuário');

O que ela faz é simplesmente pegar a tabela “classes” e inserir o valor “Usuário” no campo “nome”. Em nosso caso, é uma inserção simples, e não precisamos passar a ID, pois ela é gerada automaticamente.
Vamos inserir as classes restantes.

INSERT INTO `classes` (`nome`) VALUES ('Moderador');
INSERT INTO `classes` (`nome`) VALUES ('Super Moderador');
INSERT INTO `classes` (`nome`) VALUES ('Administrador');
INSERT INTO `classes` (`nome`) VALUES ('Programador');

E agora vamos inserir os usuários:

INSERT INTO `usuarios` (`nome`, `login`, `senha`, `classe`) VALUES ('Maria', 'maria', 'maria123', 1);
INSERT INTO `usuarios` (`nome`, `login`, `senha`, `classe`) VALUES ('Hildeu', 'hildeu', '123bbbas', 1);
INSERT INTO `usuarios` (`nome`, `login`, `senha`, `classe`) VALUES ('Jorge', 'jorge', 'vidaloka', 1);
INSERT INTO `usuarios` (`nome`, `login`, `senha`, `classe`) VALUES ('Fernando', 'fernando', '1a2b3c', 2);
INSERT INTO `usuarios` (`nome`, `login`, `senha`, `classe`) VALUES ('Felipe', 'felipe', 'harrypotter', 3);
INSERT INTO `usuarios` (`nome`, `login`, `senha`, `classe`) VALUES ('Bruno', 'bruno', 'alessandra', 3);
INSERT INTO `usuarios` (`nome`, `login`, `senha`, `classe`) VALUES ('Roberto', 'roberto', 'vanessa', 4);
INSERT INTO `usuarios` (`nome`, `login`, `senha`, `classe`) VALUES ('Vinícius', 'vinicius', 'fuzzer', 4);
INSERT INTO `usuarios` (`nome`, `login`, `senha`, `classe`) VALUES ('William', 'william', '@de#AsnH$', 5);

Observe que o nome dos campos estão delimitados por crases e que nos valores, alguns são delimitados por aspas simples e outros nem são delimitados.

Isso foi explicado um pouco acima. rsrs.

O Comando SELECT

O comando SELECT é o responsável por realizarmos buscas em nosso banco de dados. A sintaxe básica é:

SELECT campo1, campo2, campo3 FROM nome_da_tabela WHERE condicao;

campo1, campo2, campo3 são os dados que eu quero pesquisar, eu poderia simplesmente mudar para * e retornar todos os campos. As vezes você quer dados mais específicos, outras vezes não, depende da sua necessidade.

nome_da_tabela acho que é meio auto-explicativo, mas é a tabela que você quer pesquisar. Temos apenas a tabela usuarios e classes em nosso projeto.
Acho importante ressaltar que poderíamos realizar a consulta em duas, três, N tabelas.

Por exemplo, iremos consultar o nome e classe dos todos os nossos usuarios:

SELECT nome, classe FROM usuarios;

E agora vamos buscar apenas os programadores, ou seja, vamos buscar em duas tabelas:

SELECT usuarios.nome, classes.nome as classe FROM usuarios, classes WHERE classes.nome = "Programador" AND usuarios.classe = classes.id;

Veja que não é um bixo de 7 cabeças, a query (consulta) no fundo tem um sentido lógico.

“WHERE condicao” pode ser omitido, então retornaria todos os elementos, mas caso estejamos pesquisando, por exemplo todos que sejam da classe Administrador ficaria “WHERE classe = 4″.

Aqui é uma parte importante, pois podemos buscar de várias formas, a mais comum é a WHERE campo = ‘valor’, porém também temos operadores como o LIKE, o IN, o NOT.

Para exemplos melhores, recomendo ler uma apostila especializada em SQL, porém não utilizaremos esses operadores neste artigo.

O Comando UPDATE

Este comando acho que não preciso encher de firula, ele simplesmente atualiza os dados da tabela.
Sua sintaxe é:

UPDATE nome_tabela SET nome_campo = 'novo_valor' WHERE condicao;

Esse comando é meio que auto explicativo, mas vamos a algumas observações:

1 – Podemos atualizar mais de um campo ao mesmo tempo, nesse caso apenas separaríamos por uma vírgula (,) e colocaríamos outro_campo = ‘outro_valor’.
2 – Se não for utilizada a condição, você irá alterar os campos de todos os registros, isso é meio problemático rs. A não ser que você queira realmente fazer isso, como desativar todos os usuários, resetar todas as senhas, não sei rsrsrs.

Um exemplo para alterar a senha do usuário william:

UPDATE usuarios SET senha='123mudarasenha' WHERE login = 'william';

O comando DELETE

O comando DELETE serve simplesmente para remover, apagar, deletar, dar cabo (como preferir chamar, rsrs) em um determinado dado de uma determinada tabela, ou todos os dados de uma tabela, caso utilizado sem o WHERE.

Sua sintaxe básica é:

DELETE FROM nome_da_tabela WHERE condicao;

Como você já deve ter imaginado, se eu executar este comando sem passar a condição WHERE irei sumir com todos os dados dessa tabela. No Workbench por padrão é bloqueado UPDATE e DELETE sem a clausula WHERE, mas pode ser desativado, mas isso não é regra.

O comando TRUNCATE

O comando TRUNCATE tem por finalidade limpar todos os dados de uma tabela, ou seja, além de eliminar todos os registros, ele reinicia a numeração de auto incremento.

Sua sintaxe é:

TRUNCATE TABLE nome_da_tabela;

Bom, finalizado essa simplória parte sobre SQL, vamos agora como manipular isso em PHP.

Brincando de MySQL com PHP

Bom, agora vamos a parte que interessa. O que iremos fazer? Bom, não temos muita coisa no banco de dados, apenas duas tabelas.

Então, vamos realizar um simples sistema de gerenciamento, não iremos utilizar os dados de login nem nada, são apenas para “enfeite”, até porque, já tenho um post sobre sistemas de login

Bom, iremos divir o artigo em partes:

1 – Criando o arquivo de conexão
2 – Listagem de todos os usuários;
3 – Edição de usuário;
4 – Inserir novos usuários;
5 – Deletar usuários;
6 – Listagem de todas as classes;
7 – Edição de classes;
8 – Inserir novas classes;
9 – Deletar classes;

Criando o arquivo de conexão

O arquivo de conexão será responsável por, deerr, fazer a conexão. Ele deverá ser incluído em todas as páginas.

A função para conectar ao mysql é a mysql_connect.

Nossa página ficará da seguinte forma:

/* ---------- ARQUIVO DE CONEXÃO COM O BANCO DE DADOS MYSQL ---------- */

/**
 * Constante de login do servidor de dados mysql
 */
define("DB_LOGIN", "root");

/**
 * Constante da senha do servidor de dados mysql
 */
define("DB_SENHA", "123456");

/**
 * Endereço do servidor de dados mysql
 */
define("DB_LOCAL", "127.0.0.1");

/**
 * Banco de dados que iremos utilizar no servidor de dados conectado
 */
define("DB_BANCO", "site-local");

/**
 * Conectamos e armazenamos o link de conexão
 */
$link = mysql_connect(DB_LOCAL, DB_LOGIN, DB_SENHA) or die("Não foi possível conectar com o servidor de dados.");;

/**
 * Selecionamos agora o banco de dados
 */
mysql_select_db(DB_BANCO, $link) or die("Não foi possível selecionar o banco no servidor especificado.");

/**
 * Definimos a codificação do banco como UTF-8, para evitar problemas com encoding
 */
mysql_set_charset("utf8", $link);

Esse arquivo será o responsável por conectar e não precisará sofrer mais nenhuma alteração.

Só lembrando que ele deverá ser incluído em todas as páginas que forem utilizar banco de dados.

Listagem de todos os usuários

Bom, para nossa listagem de usuários, não irei me focar em orientação a objetos, nem frameworks. Não utilizarei PDO, pois pretendo tentar passar a função nativa do mysql para PHP além de que, pretendo escrever posteriormente um artigo sobre PDO, na qual vocês poderão testar qual vocês acham melhor.

Para nossa listagem de usuários, iremos precisar de uma tabela, realizar a consulta, um loop para preencher os dados, nada muito complicado.

Nossa página ficaria mais ou menos semelhante a abaixo comentada:

<?php
require_once("conexao.php");
?>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>Listagem de usuários</title>
    </head>
    <body>
        
        <!-- CRIAMOS UMA TABELA PARA A LISTAGEM DE USUÁRIOS -->
        <table>
            <tr>
                <td>ID</td>
                <td>Nome</td>
                <td>Login</td>
                <td>Senha</td>
                <td>Classe</td>
                <td>Ações</td>
            </tr>
            <?php
            
            //Crio a SQL de consulta
            $qry = "SELECT u.id, u.nome, u.login, u.senha, c.nome as classe
                    FROM usuarios u
                    INNER JOIN classes c ON c.id = u.classe
                    ORDER BY u.nome ASC;";
            
            //Executo a consulta
            $exe_usuarios = mysql_query($qry);
            
            //agora faço um while de todos os resultados para preencher a tabela
            while($row = mysql_fetch_array($exe_usuarios)){
                ?>
                <tr>
                    <td><?php echo $row["id"]; ?></td>
                    <td><?php echo $row["nome"]; ?></td>
                    <td><?php echo $row["login"]; ?></td>
                    <td><?php echo $row["senha"]; ?></td>
                    <td><?php echo $row["classe"]; ?></td>
                    <td>
                        <a href="editar_usuario.php?id=<?php echo $row["id"]; ?>">Editar</a>
                        <a href="deletar_usuario.php?id=<?php echo $row["id"]; ?>">Deletar</a>
                    </td>
                </tr>
                <?php
            }
            
            ?>
        </table>
        <!-- FIM DA TABELA -->
        
    </body>
</html>

Edição de usuário

Observe que na tabela anterior, nas ações de editar e deletar, foi passado junto ao link a ID, pois iremos tratar lá qual usuários iremos alterar.

Para tanto, precisaremos de realizar uma conexão com o banco e rodar uma Query (Consulta) de atualização (UPDATE). Os dados irão vir de um formulário HTML.

Segue o código comentado:

<?php
require_once("conexao.php");

//pego a ID da url
$id = (int) 0 + $_GET["id"];

//verifico se a ID ainda é numérica, pois caso não seja pode ser
//uma tentativa de SQL Injection
if (!is_numeric($id)) {
    die("Tentativa de SQL Injection.");
}

//verifico se clicaram no botão atualizar, ou seja, foi feito um POST
if (getenv("REQUEST_METHOD") == "POST") {
    //irei utilizar um método mais manual para evitar sql inject
    //Levaremos em consideração que alguns caracteres não devem ser
    //cadastrados no banco, vamos criar um array para isto
    $invalidos = (array) array("'", "\"", ";", "--");
    //verificamos se no POST não tem nenhum desses dados em nenhum dos campos
    foreach ($_POST as $valor) {
        foreach ($invalidos as $invalido) {
            if(strpos($valor, $invalido) !== false){
                die("Tentativa de SQL Inject. N&atilde;o utilize nenhum desses caracteres: <strong>" . implode(" ", $invalidos) . "</strong>");
            }
        }
    }
    
    //se chegou aqui, os dados foram validados, agora faço a consulta de atualizar no banco
    $qry_atualizacao = "UPDATE usuarios SET nome = '{$_POST["nome"]}', login = '{$_POST["login"]}', senha = '{$_POST["senha"]}', classe = {$_POST["classe"]} WHERE id = {$id};";
    
    //apenas executo a query
    if(mysql_query($qry_atualizacao)){
        $status_atualizacao = "Usuário atualizado com sucesso.";
    }else{
        $status_atualizacao = "O cadastro não foi atualizado. Informe o administrador do sistema sobre este erro e como fez para chegar até ele.";
    }
    
}

//caso contrário, faço a consulta no banco normalmente e exibo os dados
//em um formulário HTML
//Crio a string da query, observe que não estou juntando a tabela de classes
//pois desta vez me interessa o número e não o nome
$qry_usuario = "SELECT * FROM usuarios WHERE id = {$id};";
$exe_usuarios = mysql_query($qry_usuario);

//verifico se houve 1 e apenas um usuário, caso isso não seja verdade, gero um erro
if (mysql_num_rows($exe_usuarios) != 1) {
    die("Erro ao consultar. Itens retornado: " . mysql_num_rows($exe_usuarios) . ". Deve ser apenas 1.");
}

//se cheguei aqui, está tudo ok, agora faço a form e 
$usuario = mysql_fetch_array($exe_usuarios, MYSQL_ASSOC);

//agora eu busco todas as classes, vou fazer um combo box para que possa editar a classe também
$qry_classes = "SELECT * FROM classes ORDER BY nome ASC;";
$exe_classes = mysql_query($qry_classes);
?>

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>Listagem de usuários</title>
    </head>
    <body>
        
        <!-- VERIFICO SE EXISTE UMA VARIAVEL CHAMADA ATUALIZADO E EXIBO A MENSAGEM -->
        <?php if(isset($status_atualizacao)): echo $status_atualizacao; endif; ?>
        
        <!-- AQUI CRIAREMOS UMA TABELA E UM FORM COM OS DADOS DO USUÁRIO JÁ PREENCHIDOS -->
        
        <!-- é importante que o método seja o post -->
        <!-- o action é em para qual página passaremos os dados, será para ela mesmo -->
        <form name="frmEdicao" method="post" action="editar_usuario.php?id=<?php echo $id; ?>">
            <table>
                <tr>
                    <td>Nome:</td>
                    <td><input name="nome" type="text" value="<?php echo $usuario["nome"]; ?>" size="25" /></td>
                </tr>
                <tr>
                    <td>Login:</td>
                    <td><input name="login" type="text" value="<?php echo $usuario["login"]; ?>" size="25" /></td>
                </tr>
                <tr>
                    <td>Senha:</td>
                    <td><input name="senha" type="text" value="<?php echo $usuario["senha"]; ?>" size="25" /></td>
                </tr>
                <tr>
                    <td>Classe:</td>
                    <td>
                        <!-- FAÇO UM WHILE DE TODAS AS CLASSES -->
                        <select name="classe">
                            <?php
                            while($classe = mysql_fetch_array($exe_classes)){
                                ?>
                                    <option <?php if($usuario["classe"] == $classe["id"]): ?>selected="selected"<?php endif; ?> value="<?php echo $classe["id"]; ?>"><?php echo $classe["nome"]; ?></option>
                                <?php
                            }
                            ?>
                        </select>
                    </td>
                </tr>
                <tr>
                    <td colspan="2"><input type="submit" value="Alterar dados" /></td>
                </tr>
            </table>
        </form>
              
        <!-- FIM DA TABELA E DO FORM -->
        
    </body>
</html>

Inserir novos usuários

Bom, e lá vamos nós. Nesta parte de inserir usuários, vamos aproveitar a mesma estrutura da página de edição, com algumas pequenas alterações, como por exemplo, os dados não virão preenchidos.

Atenção apenas a parte de inserção, que antes era a de alteração.

Para tal, antes de começarmos a codificar a página de inserção, insira um link na index.php para a página de cadastro. Cole o código abaixo antes da TAG , ou em qualquer outro lugar que quiser.

<a href="inserir_usuario.php">Cadastro de Usuários</a>

E o código da página de inserção de usuário fica da seguinte forma:

<?php
require_once("conexao.php");
//verifico se clicaram no botão atualizar, ou seja, foi feito um POST
if (getenv("REQUEST_METHOD") == "POST") {
    //irei utilizar um método mais manual para evitar sql inject
    //Levaremos em consideração que alguns caracteres não devem ser
    //cadastrados no banco, vamos criar um array para isto
    $invalidos = (array) array("'", "\"", ";", "--");
    //verificamos se no POST não tem nenhum desses dados em nenhum dos campos
    foreach ($_POST as $valor) {
        foreach ($invalidos as $invalido) {
            if (strpos($valor, $invalido) !== false) {
                die("Tentativa de SQL Inject. N&atilde;o utilize nenhum desses caracteres: <strong>" . implode(" ", $invalidos) . "</strong>");
            }
        }
    }

    //valido os dados antes de inserir
    $valido = true;
    $mensagem_erro = "";
    
    //valido nome
    if(strlen($_POST["nome"]) < 3){
        $valido = false;
        $mensagem_erro .= "Nome muito curto. Mínimo de 3 caracteres.<br/>";
    }
    
    //valido login
    if(strlen($_POST["login"]) < 5){
        $valido = false;
        $mensagem_erro .= "Login muito curto. Mínimo de 5 caracteres.<br/>";
    }
    
    //valido senha
    if(strlen($_POST["senha"]) < 6){
        $valido = false;
        $mensagem_erro .= "Senha muito curta. Mínimo de 6 caracteres.<br/>";
    }
    
    //valido a classe
    if(!is_numeric($_POST["classe"])){
        $valido = false;
        $mensagem_erro .= "Campo classe informado não é um número.<br/>";
    }
    
    if ($valido) {
        //se chegou aqui, os dados foram validados, agora faço a consulta de inserir no banco
        $qry_insert = " INSERT INTO usuarios (nome, login, senha, classe)
                    VALUES ('{$_POST["nome"]}', '{$_POST["login"]}', '{$_POST["senha"]}', {$_POST["classe"]});";

        //apenas executo a query
        if (mysql_query($qry_insert) === false) {
            //se der erro, exibo uma mensagem nada amigável na tela
            die("Ocorreu um erro ao inserir este usuário no banco de dados.");
        } else {
            //caso contrário, volto para a página de listagem de usuários
            header("location: index.php");
        }
    }
}

//busco todas as classes, vou fazer um combo box para que possa editar a classe também
$qry_classes = "SELECT * FROM classes ORDER BY nome ASC;";
$exe_classes = mysql_query($qry_classes);
?>

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>Cadastro de usuários</title>
    </head>
    <body>
        
        <!-- SE EXISTIR ALGUMA MENSAGEM DE ERRO EXIBIMOS ELA AQUI -->
        <?php if(isset($mensagem_erro[1])): echo $mensagem_erro; endif; ?>
        
        <!-- AQUI CRIAREMOS UMA TABELA E UM FORM COM OS DADOS DO USUÁRIO JÁ PREENCHIDOS -->

        <!-- é importante que o método seja o post -->
        <!-- o action é em para qual página passaremos os dados, será para ela mesmo -->
        <form name="frmEdicao" method="post" action="inserir_usuario.php">
            <table>
                <tr>
                    <td>Nome:</td>
                    <td><input name="nome" type="text" value="<?php if (isset($_POST)): echo $_POST["nome"]; endif; ?>" size="25" /></td>
                </tr>
                <tr>
                    <td>Login:</td>
                    <td><input name="login" type="text" value="<?php if (isset($_POST)): echo $_POST["login"]; endif; ?>" size="25" /></td>
                </tr>
                <tr>
                    <td>Senha:</td>
                    <td><input name="senha" type="text" value="<?php if (isset($_POST)): echo $_POST["senha"]; endif; ?>" size="25" /></td>
                </tr>
                <tr>
                    <td>Classe:</td>
                    <td>
                        <!-- FAÇO UM WHILE DE TODAS AS CLASSES -->
                        <select name="classe">
                            <?php
                            while ($classe = mysql_fetch_array($exe_classes)) {
                                ?>
                                <option <?php if (isset($_POST) && $_POST["classe"] == $classe["id"]): ?>selected="selected"<?php endif; ?> value="<?php echo $classe["id"]; ?>"><?php echo $classe["nome"]; ?></option>
                                <?php
                            }
                            ?>
                        </select>
                    </td>
                </tr>
                <tr>
                    <td colspan="2"><input type="submit" value="Inserir usuário" /></td>
                </tr>
            </table>
        </form>

        <!-- FIM DA TABELA E DO FORM -->

    </body>
</html>

Deletar usuários

A página de deletar usuários será a mais fácil de todas, pois não utilizarei interface e tal, a única opção de deletar será o link fornecido ao lado do editar.

Eu sei que alguém pode clicar por engano, mas não é do tutorial ensinar tratar esse tipo de coisa e sim como manusear MySQL utilizando PHP.

Segue o código limpo e clean!

//pego a ID e verifico se é numérica, caso não seja, pode ser tentativa
//de SQL Inject
$id = (int) 0 + $_GET["id"];

if(!is_numeric($id)){
    die("Tentativa de SQL Injection. ID deve ser numérica.");
}

//se cheguei aqui, tudo OK, incluo o arquivo de conexão, deleto o registro e
//volto a página inicial, de listagem

require_once("conexao.php");

if(mysql_query("DELETE FROM usuarios WHERE id = {$id};")){
    header("location: index.php?del=ok");
}else{
    header("location: index.php?del=fail");    
}

O que falta fazer?

Bom amigos, chegamos ao final de mais um artigo, acredito que neste ponto vocês possam ser capazes de fazer os módulos restantes e também já criar seus próprios módulos.

O que ficou faltando?
Listagem de todas as classes, Edição de classes, Inserir novas classes, Deletar classes.

Para aquele que tem preguiça de de ctrl + c e ctrl + v, segue um link para meu projeto completo Projeto completo + Dump do banco de dados.