Notas de estudo PHPPDO lib.culog.cn 13 de novembro de 2007 09:36 Autor: Liu Shui Meng Chun [Grande, Médio, Pequeno]
■O que é DOP?
A extensão POD (PHP Data Object) foi adicionada no PHP5. No PHP6, o PDO será usado por padrão para conectar-se ao banco de dados. Todas as extensões não-PDO serão removidas da extensão no PHP6. Esta extensão fornece a classe PDO integrada ao PHP para acessar o banco de dados. Diferentes bancos de dados usam o mesmo nome de método para resolver o problema de conexões de banco de dados inconsistentes.
Eu configurei para desenvolvimento no Windows.
■O objetivo do PDO é fornecer uma API leve, clara e conveniente que unifique os recursos comuns de várias bibliotecas RDBMS, mas não exclua recursos mais avançados. Fornece um maior grau opcional de abstração/compatibilidade por meio de scripts PHP.
■Características do DOP:
desempenho. A PDO aprendeu desde o início sobre os sucessos e fracassos do dimensionamento dos bancos de dados existentes. Como o código do PDO é totalmente novo, temos a oportunidade de redesenhar o desempenho desde o início para aproveitar as vantagens dos recursos mais recentes do PHP 5. habilidade. O PDO foi projetado para fornecer funcionalidade comum de banco de dados como base, ao mesmo tempo que fornece acesso fácil aos recursos exclusivos de um RDBMS. Simples. O PDO foi projetado para facilitar o trabalho com bancos de dados. A API não força sua entrada no código e deixa claro o que cada chamada de função faz. Extensível em tempo de execução. A extensão PDO é modular, permitindo carregar drivers para o back-end do seu banco de dados em tempo de execução sem precisar recompilar ou reinstalar todo o programa PHP. Por exemplo, a extensão PDO_OCI implementa a API do banco de dados Oracle em vez da extensão PDO. Existem também drivers para MySQL, PostgreSQL, ODBC e Firebird, com mais em desenvolvimento.
■Instalar DOP
O que tenho aqui é uma extensão PDO para desenvolvimento no WINDOWS. Se você deseja instalar e configurar no Linux, procure outro lugar.
Requisitos de versão:
Já está incluído no pacote de programas do php5.1 e versões posteriores;
Para php5.0.x, você precisa baixá-lo em pecl.php.net e colocá-lo em sua biblioteca de extensões, que é a pasta ext da pasta onde o PHP está localizado;
O manual diz que versões anteriores à 5.0 não podem executar extensões PDO.
Configuração:
Modifique seu arquivo de configuração php.ini para que ele suporte pdo (se você não entende php.ini, primeiro descubra que você precisa modificar o php.ini exibido ao chamar sua função phpinfo())
Pacote
Remova o ponto e vírgula na frente de extension=php_pdo.dll O ponto e vírgula é o símbolo de comentário do arquivo de configuração php.
Existem mais
;extensão=php_pdo.dll
;extensão=php_pdo_firebird.dll
;extensão=php_pdo_informix.dll
;extensão=php_pdo_mssql.dll
;extensão=php_pdo_mysql.dll
;extensão=php_pdo_oci.dll
;extensão=php_pdo_oci8.dll
;extensão=php_pdo_odbc.dll
;extensão=php_pdo_pgsql.dll
;extensão=php_pdo_sqlite.dll
O banco de dados correspondente a cada extensão é:
Nome do driverBancos de dados suportadosPDO_DBLIBFreeTDS / Microsoft SQL Server / SybasePDO_FIREBIRDFirebird/Interbase 6PDO_INFORMIXIBM Informix Dynamic ServerPDO_MYSQLMySQL 3.x/4.xPDO_OCIOracle Call InterfacePDO_ODBCODBC v3 (IBM DB2, unixODBC e win32 ODBC)PDO_PGSQLPostgreSQLPDO_SQLITESQLite 3 e SQL ite 2
Qual banco de dados você deseja utilizar, basta colocar o correspondente Basta remover o símbolo de comentário ";" antes da expansão.
■Usando DOP
Presumo aqui que você instalou o mysql. Caso contrário, encontre uma maneira de instalá-lo primeiro. O meu é mysql5.0.22, e outros que usam o MySQL 4.0.26 também podem usá-lo.
★Conexão de banco de dados:
Usamos o exemplo a seguir para analisar o banco de dados de conexão PDO,
<?php
$dbms='mysql'; //Tipo de banco de dados Oracle usa ODI. Para desenvolvedores, se você usar bancos de dados diferentes, você só precisa alterar isso e não precisa se lembrar de tantas funções.
$host='localhost';//Nome do host do banco de dados
$dbName='test'; //Banco de dados usado
$user='root'; //Nome de usuário da conexão com o banco de dados
$pass=''; //Senha correspondente
$dsn="$dbms:host=$host;dbname=$dbName";
//
tentar{
$dbh=newPDO($dsn,$user,$pass);//Inicializar um objeto PDO significa criar o objeto de conexão com o banco de dados $dbh
echo "Conexão bem-sucedida<br/>";
/*Você também pode realizar uma operação de pesquisa
foreach($dbh->query('SELECT * from FOO')as$row){
print_r($row);//Você pode usar echo($GLOBAL);
}
*/
$dbh=nulo;
}catch(PDOException$e){
die("Erro!: ".$e->getMessage()."<br/>");
}
//Por padrão, esta não é uma conexão longa. Se você precisa de uma conexão longa com o banco de dados, você precisa adicionar um parâmetro no final: array(PDO::ATTR_PERSISTENT => true).
$db=newPDO($dsn,$usuário,$pass,array(PDO::ATTR_PERSISTENT=>true))
;
★ Consulta ao banco de dados:
Já realizamos uma consulta acima e também podemos utilizar a seguinte consulta:
<?php
$db->setAttribute(PDO::ATTR_CASE,PDO::CASE_UPPER); //Definir atributos
$rs=$db->query("SELECT * FROM foo");
$rs->setFetchMode(PDO::FETCH_ASSOC);
$result_arr=$rs->fetchAll();
print_r($resultado_arr);
?>
Como o método setAttribute() é usado acima, os dois parâmetros são colocados para forçar o nome do campo a ficar em letras maiúsculas. A seguir estão os parâmetros de PDO::setAttribute():
PDO::ATTR_CASE: Força o nome da coluna a ficar em um formato conforme detalhado abaixo (segundo parâmetro):
PDO::CASE_LOWER: Força o nome da coluna a ficar em minúsculas
. : :CASE_NATURAL: Os nomes das colunas seguem a forma original
PDO::CASE_UPPER: Força os nomes das colunas para letras maiúsculas.
PDO::ATTR_ERRMODE: Mensagem de erro
PDO::ERRMODE_SILENT: Não exibe informações de erro, apenas código de erro.
PDO::ERRMODE_WARNING
: Exibe erro de aviso.
PDO::ATTR_ORACLE_NULLS (válido não só para ORACLE, mas também para outros bancos de dados): ) especifica o valor correspondente em php para o valor NULL retornado pelo banco de dados.
PDO::NULL_NATURAL: inalterado.
PDO::NULL_EMPTY_STRING: String vazia é convertida em NULL.
PDO::NULL_TO_STRING: NULL é convertido em uma string vazia.
PDO::ATTR_STRINGIFY_FETCHES: Converte valores numéricos em strings ao buscar. Requer bool.
PDO::ATTR_STATEMENT_CLASS: Define a classe de instrução fornecida pelo usuário derivada de PDOStatement. ))
.PDO::ATTR_AUTOCOMMIT(disponível em OCI, Firebird e MySQL): Se deve autocommit cada instrução
PDO::MYSQL_ATTR_USE_BUFFERED_QUERY(disponível em MySQL): Use consultas em buffer.
$rs->setFetchMode(PDO::FETCH_ASSOC); no exemplo é PDOStatement::setFetchMode(), uma declaração do tipo de retorno.
Existem os seguintes:
PDO::FETCH_ASSOC-- formato de array associativo
PDO::FETCH_NUM -- Formulário de array de índice numérico
PDO::FETCH_BOTH -- Ambos estão disponíveis em formato de array, que é o padrão
PDO::FETCH_OBJ -- na forma de um objeto, semelhante ao mysql_fetch_object() anterior. Para
mais declarações de tipo de retorno (PDOStatement::nome do método), consulte o manual.
★Inserir, atualizar, excluir dados,
$db->exec("DELETE FROM `xxxx_menu` onde mid=43");
Para resumir brevemente as operações acima:
As operações de consulta são principalmente PDO::query(), PDO::exec(), PDO::prepare().
PDO::query() é usado principalmente para operações que retornam resultados registrados, especialmente operações SELECT.
PDO::exec() é principalmente para operações que não retornam um conjunto de resultados, como INSERT, UPDATE, DELETE e outras operações. O resultado que ele retorna é o número de colunas afetadas pela operação atual.
PDO::prepare() é principalmente uma operação de pré-processamento. Você precisa usar $rs->execute() para executar a instrução SQL no pré-processamento. Este método pode vincular parâmetros e é bastante poderoso. . Todos Você pode consultar manuais e outras documentações.
As principais operações para obtenção do conjunto de resultados são: PDOStatement::fetchColumn(), PDOStatement::fetch(), PDOStatement::fetchALL().
PDOStatement::fetchColumn() é um campo do primeiro registro especificado no resultado da busca. O padrão é o primeiro campo.
PDOStatement::fetch() é usado para obter um registro.
PDOStatement::fetchAll() é reunir todos os conjuntos de registros em um. Para obter os resultados, você pode definir o tipo do conjunto de resultados necessário por meio de PDOStatement::setFetchMode.
Existem também duas operações adjacentes, uma é PDO::lastInsertId() e PDOStatement::rowCount(). PDO::lastInsertId() retorna a última operação de inserção e o tipo de coluna de chave primária é o último ID de incremento automático.
PDOStatement::rowCount() é usado principalmente para o conjunto de resultados afetado pelas operações DELETE, INSERT e UPDATE de PDO::query() e PDO::prepare(), e é inválido para o método PDO::exec() e operações SELECT.
★Transações e envio automático
Neste ponto, você se conectou ao mysql através do PDO. Antes de emitir consultas, você deve entender como o PDO gerencia as transações. Se você nunca foi exposto a transações antes, primeiro você deve conhecer as quatro características das transações: Atomicidade, Consistência, Isolamento e Durabilidade, ou seja, ACID. Em termos leigos, para qualquer trabalho realizado dentro de uma transação, mesmo que seja realizado em etapas, há uma garantia de que o trabalho será aplicado com segurança ao banco de dados e não será afetado por solicitações de outras conexões enquanto o trabalho estiver sendo submetido . influência. O trabalho transacional pode ser desfeito automaticamente mediante solicitação (supondo que você ainda não o tenha confirmado), o que facilita muito o tratamento de erros em scripts.
As transações geralmente são implementadas acumulando um lote de alterações e tornando-as efetivas ao mesmo tempo. A vantagem disso é que pode melhorar muito a eficiência dessas atualizações. Em outras palavras, as transações podem tornar os scripts mais rápidos e potencialmente mais robustos (embora as transações precisem ser usadas corretamente para obter tais benefícios).
Infelizmente, nem todo banco de dados suporta transações (Mysql5 suporta transações, mysql4 eu não sei), então quando a conexão é aberta pela primeira vez, o PDO precisa ser executado no chamado modo "auto-commit". O modo de confirmação automática significa que se o banco de dados suportar transações, cada consulta executada terá sua própria transação implícita e, se o banco de dados não suportar transações, cada consulta não terá tal transação. Se você precisar de uma transação, deverá usar o método PDO::beginTransaction() para iniciar uma transação. Se o driver subjacente não suportar transações, uma PDOException será lançada (independentemente das configurações de tratamento de erros: esta é sempre uma condição de erro fatal). Dentro de uma transação, você pode usar PDO::commit() ou PDO::rollBack() para finalizar a transação, dependendo se o código executado na transação foi bem-sucedido.
Quando o script terminar, ou quando uma conexão estiver prestes a ser encerrada, se houver uma transação pendente, o PDO reverterá automaticamente a transação. Esta é uma medida de segurança para ajudar a evitar inconsistências se o script terminar de forma anormal - se a transação não for confirmada explicitamente, então presume-se que haverá uma inconsistência em algum lugar, então uma reversão será executada para preservar a segurança dos dados.
//Exemplo de http://www.ibm.com/developerworks/cn/db2/library/techarticles/dm-0505furlong/index.html
tentar{
$dbh=new PDO('odbc:SAMPLE','db2inst1','ibmdb2',
array(PDO_ATTR_PERSISTENT=>true));
echo"Conectadon";
$dbh->setAttribute(PDO_ATTR_ERRMODE,PDO_ERRMODE_EXCEPTION);
$dbh->beginTransaction();
$dbh->exec("inserir nos valores da equipe (id, primeiro, último) (23, 'Joe', 'Bloggs')");
$dbh->exec("inserir em alteração salarial (id, valor, data da alteração)
valores (23, 50000, AGORA())");
$dbh->commit();
}catch(Exceção $e){
$dbh->rollBack();
echo"Falha: ".$e->getMessage();
}
No exemplo acima, suponha que criamos um conjunto de entradas para um novo funcionário com um número de identificação, que é 23. Além de inserir os dados básicos da pessoa, também precisamos registrar o salário do funcionário. É simples fazer as duas atualizações separadamente, mas ao incluir ambas as atualizações nas chamadas BeginTransaction() e commit(), você garante que ninguém mais poderá ver as alterações até que elas sejam concluídas. Se ocorrer um erro, o bloco catch pode reverter todas as alterações que ocorreram desde o início da transação e imprimir uma mensagem de erro.
As atualizações não precisam ser feitas dentro de uma transação. Você também pode emitir consultas complexas para extrair dados e criar atualizações e consultas adicionais usando essas informações. Quando uma transação está ativa, é garantido que outras pessoas não poderão fazer alterações enquanto o trabalho estiver em andamento. Na verdade, isso não é 100% correto, mas é uma boa introdução se você nunca ouviu falar de transações antes.
★Declarações preparadas e procedimentos armazenados Muitos bancos de dados mais maduros suportam o conceito de declarações preparadas. O que são declarações preparadas? Você pode pensar nas instruções preparadas como um modelo compilado do SQL que deseja executar, que pode ser personalizado usando parâmetros variáveis. As instruções preparadas fornecem dois benefícios principais:
a consulta só precisa ser analisada (ou preparada) uma vez, mas pode ser executada várias vezes com parâmetros iguais ou diferentes. Quando uma consulta está pronta, o banco de dados analisa, compila e otimiza o plano para execução da consulta. Esse processo leva mais tempo para consultas complexas e pode tornar seu aplicativo significativamente mais lento se você precisar repetir a mesma consulta várias vezes com parâmetros diferentes. Ao usar instruções preparadas, você pode evitar ciclos repetidos de análise/compilação/otimização. Simplificando, as instruções preparadas utilizam menos recursos e, portanto, são executadas mais rapidamente.
Os parâmetros fornecidos às instruções preparadas não precisam ser colocados entre aspas; Se seu aplicativo usar exclusivamente instruções preparadas, você pode ter certeza de que nenhuma intrusão SQL poderá ocorrer. (No entanto, ainda existe um risco se você ainda basear outras partes da consulta em entradas não confiáveis).
As instruções preparadas são tão úteis que o PDO realmente quebra a regra definida no Objetivo 4: Se o driver não suportar instruções preparadas, o PDO irá emular as instruções preparadas.
Exemplo: Exemplo de aplicação DOP:
<?php
'
;//Tipo de banco de dados Oracle usa ODI. Para desenvolvedores, usando bancos de dados diferentes, desde que você altere isso, você não precisa se lembrar de tantas funções.
nome de host
$dbName='test';//Banco de dados usado
$user='root';//Nome de usuário de conexão de banco de dados
$pass='';//Senha correspondente
$dsn="$dbms:host=$host;dbname= $dbNome";
classdbextendsPDO{
função pública__construct(){
tentar{
pai::__construct("$GLOBALS[dsn]",$GLOBALS['usuário'],$GLOBALS['pass']);
}catch(PDOException$e){
die("Erro: ".$e->__toString()."<br/>");
}
}
publicfinalfunctionquery($sql){
tentar{
returnparent::query($this->setString($sql));
}catch(PDOException$e){
die("Erro: ".$e->__toString()."<br/>");
}
}
privatefinalfunctionsetString($sql){
echo "Quero processar $sql";
retornar$sql;
}
}
$db=newdb();
$db->setAttribute(PDO::ATTR_CASE,PDO::CASE_UPPER);
foreach($db->query('SELECT * from xxxx_menu')as$row){
print_r($linha);
}
$db->exec('DELETE FROM `xxxx_menu` onde mid=43');
?>