Conexão Permanente com o Banco de Dados

Conexões persistentes são conexões que não fecham quando a execução do seu script termina. Quando uma conexão persistente é requisitada, o PHP checa se já existe uma conexão persistente idêntica (que foi mantida aberta anteriormente) - e, se ela existe, ele a usa. Se não existir, ele cria uma nova. Uma conexão 'idêntica' é uma conexão que foi aberta ao mesmo host, com o mesmo nome de usuário e a mesma senha (onde for aplicável).

Pessoas que não estão totalmente familiarizadas com a maneira como servidores web trabalham e distribuem a carga podem confundir conexões persistentes com o que elas não são. In particular, elas não dão a você a habilidade de abrir 'sessões de usuários' na mesma conexão, elas não dão a habilidade de construir uma transação eficientemente, e elas não fazem um monte de outras coisas. De fato, para ser extremamente claro sobre o assunto, conexões persistentes não te dão nenhuma funcionalidade que não era possível com as suas correspondentes não-persistentes.

Por que?

Tem a ver com a maneira como os servidores web funcionam. Existem três maneiras de seu servidor web utilizar o PHP para gerar páginas.

O primeiro método é usar o PHP como um CGI "wrapper". Quando executado dessa maneira, uma instância do interpretador do PHP é criada e destruída para cada requisição de página (por uma página PHP) para o seu servidor web. Como ela é destruída após cada requisição, quaisquer recursos que ela adquirir (como uma conexão para um banco de dados) são fechados quando ela é destruída. Nesse caso, não há nenhum ganho ao tentar usar conexões persistentes -- elas simplesmente não persistem.

O segundo método, o mais popular, é rodar o PHP como um módulo em um servidor com multi-processos, que atualmente só inclue o Apache. Um servidor com multi-processos tipicamente tem um processo (pai) que coordena uma série de processos (filhos) que são os que realmente fazem o trabalho de servir as páginas. Quando uma requisição chega de um cliente, ela é entregue à um dos filhos que não estiver ocupado servindo outro cliente. Isso significa que quando o mesmo cliente faz uma segunda requisição ao servidor, ele pode ser servido por um processo filho diferente do da primeira vez. Quando abre-se uma conexão persistente, cada página que requisitar serviços de SQL pode reusar a mesma conexão estabelecida ao servidor SQL.

O último método é usar o PHP como um plug-in para um servidor web multithreaded. Atualmente, o PHP4 tem suporte para ISAPI, WSAPI, e NSAPI (no Windows), todos permitindo PHP ser usado como um plug-in em servidores multithreaded como Netscape FastTrack (iPlanet), Internet Information Server (IIS) da Microsoft, e O'Reilly's WebSite Pro. O comportamento é essencialmente o mesmo do modelo multiprocessado descrito anteriormente.

Se conexões persistentes não tem nenhuma funcionalidade a mais, para que elas servem?

A resposta é extremamente simples -- eficiência. Conexôes persistentes são boas se o sobrecarga (overhead) de criar uma conexão ao seu servidor SQL for alta. Saber se essa sobrecarga é alta depende de vários fatores. Como que tipo de banco de dados é, se está ou não na mesma máquina onde o servidor web está, o quão carregada de trabalho está a máquina hospedando o servidor SQL e assim por diante. O ponto é que se a sobrecarga de conexão for alta, conexões persistentes ajudam consideravelmente. Elas fazem com que os processos filhos simplesmente conectam-se uma vez só durante toda sua duração, ao invés de cada vez que eles processam uma página que requer uma conexão ao servidor SQL. Isso significa que cada filho que abriu uma conexão persistente terá sua própria conexão aberta ao servidor. Por exemplo, se você tiver 20 processos filhos diferentes que rodassem um script que fizesse uma conexão persistente à um servidor SQL, você teria 20 conexões diferentes ao banco, uma de cada filho.

Perceba, no entanto, que isso pode ter algumas desvantagens se você estiver usando um banco com limite de conexões que é excedido pela conexões persistentes filhas. Se seu banco tem um limite de 16 conexões simultâneas, e durante um momento de pico de acessos, 17 processos filhos tentam fazer a conexão, um deles não será capaz. Se houver bugs no seus scripts que não permitem que as conexões se fechem (como loops infinitos) o banco de dados com apenas 16 conexões pode rapidamente ficar sobrecarregado. Procure na documentação do seu banco por informações sobre como lidar com conexões ociosas ou abandonadas.

Aviso
Existem mais alguns cuidados a se tomar quando usando conexões persistentes. Um deles é que, quando usando travamento de tabela em uma conexão persistente, se o script por qualquer razão não pode destravar a mesma, então scripts subsequentes usando a mesma conexão serão bloqueados indefinidamente e pode ser preciso reiniciar o servidor http ou o banco de dados. Outro cuidado a se ter é, quando usando transações, um bloco de transação também será carregado para o próximo script que usar a conexão se a execução do script terminar primeiro que o bloco de transação. Em ambos os casos, você pode usar register_shutdown_function() para registrar uma função simples de limpeza para destravar suas tabelas e fazer roll back de suas transação. O ideal é evitar o problema completamente não usando conexões persistentes em scripts que usam travamento de tabelas ou transações (você ainda pode usar elas nos outros casos).

Um resumo importante. Conexões persistente foram feitas para ter um mapeamento de um-para-um com conexões normais. Isso significa que você deve sempre ser capaz de substituir conexões persistentes com conexões não-persistentes e isso não mudará a maneira como seu script se comporta. Pode (e provavelmente irá) mudar a eficiência do mesmo, mas não o seu comportamento!

Eu sempre usei a classe PHPMailer... Acho ela fantástica.

Para baixar a classe, acesse: http://phpmailer.codeworxtech.com

Segue abaixo um exemplo de como enviar e-mails com ela:

1. require("class.phpmailer.php");  
2.   
3. $mail = new PHPMailer();  
4.   
5. $mail->From     = "seu@email.com";  
6. $mail->FromName = "Seu Nome";  
7. $mail->Host     = "smtp.seudominio.com.br";  
8. $mail->Mailer   = "smtp"; 
   
9. //$mail->SMTPSecure   = "ssl"; // Se tiver SSL no SMTP
   
10.   
11.    // Corpo
    
12.     $body  = "Teste de e-mail com PHP Mailer.";  
13.     $body .= "Apenas um teste."; 
    
14. 
    
15.     $mail->Body    = $body;  
16.     $mail->AddAddress("destino@email.com");  
17.     $mail->AddStringAttachment("arquivo.zip");  //se quiser anexar algo
    
18.   
19.     if(!$mail->Send())  {
20.         echo "Nao consegui enviar";
21.  }
    
22. }

Abraços

Guilherme

Trigger: é chamada quando uma tabela é excitada por um dos comandos: INSERT, DELETE ou UPDATE.
 Trigger = gatilho, disparador;====================== create database locadora;use locadora;

create table filmes(
 cod_fil int not null auto_increment,
 titulo varchar(255),
 constraint pk_filmes
  primary key(cod_fil)
) engine=innodb;

create table clientes(
 cod_cli int not null auto_increment,
 nome varchar(255),
 constraint pk_clientes
  primary key(cod_cli)
) engine=innodb;
create table filmes_clientes(
  cod_fil int not null,
 cod_cli int not null,
 constraint fk_filmes
   foreign key(cod_fil)
      references filmes(cod_fil),
  constraint fk_clientes
    foreign key(cod_cli)
      references clientes(cod_cli)
) engine=innodb;create table tblog(
 cod int not null auto_increment,
 filme int not null,
 cliente int not null,
 retirada date not null,
 devolucao date,
 primary key(cod)
) engine=myisam;delimiter |
CREATE TRIGGER tralugar
  before insert ON filmes_clientes
  FOR EACH ROW BEGIN
   insert into tblog(filme,cliente,retirada)
  values(new.cod_fil,new.cod_cli,now());  END;
  |
  delimiter ;
 delimiter |
 CREATE TRIGGER trdevolver
   after delete ON filmes_clientes
   FOR EACH ROW BEGIN
     update tblog set devolucao=now()
       where filme=old.cod_fil
       and  cliente=old.cod_cli;
   END;
  |
 delimiter ;/// DADOS DE TESTES: insert into filmes values(1,"matrix"),(2,"MIB");
insert into clientes values(1,"joao"),(2,"Pedro");